template <class T, class ...Options>
class treap_set;
template <class T, class ...Options>
class treap_multiset;
template <class T, class ...Options>
class treap;

Эти контейнеры получают те же опции, описанные в разделе. Как использовать Boost.Intrusive

Также они могут получить дополнительные опции:

Функция объекта по умолчанию<priority_compare<T>>будет называть неквалифицированную функцию<priority_order>, передавая две постоянные<T>ссылки в качестве аргументов, и должна вернуться истинной, если первый аргумент имеет более высокий приоритет (он будет искаться быстрее), вызывая строгий слабый порядок. Функция будет найдена с помощью поиска ADL, так что пользователю просто нужно определить функцию<priority_order>в том же пространстве имен, что и класс:

struct MyType
{
   friend bool priority_order(const MyType &a, const MyType &b)
   {...}
};

или

namespace mytype {
struct MyType{ ... };
bool priority_order(const MyType &a, const MyType &b)
{...}
}  //namespace mytype {

В целом, интрузивные контейнеры предлагают надежные гарантии безопасности, но контейнеры для погрузки должны иметь дело с двумя функторами (один для заказа стоимости, другой для приоритетного заказа). Кроме того, операции по стиранию помета требуют ротации на основе функции приоритетного порядка, и эта проблема ухудшает обычную гарантию отсутствия броска<erase(const_iterator)>. Тем не менее, инвазивное поведение предлагает самое сильное поведение в этих ситуациях. В резюме:

Теперь рассмотрим небольшой пример с использованием двоичных крючков деревьев поиска и контейнеров<treap_set>/<treap_multiset>:

#include <boost/intrusive/treap_set.hpp>
#include <vector>
#include <functional>
#include <cassert>
using namespace boost::intrusive;
class MyClass : public bs_set_base_hook<> //This is a base hook
{
   int int_;
   unsigned int prio_;
   public:
   //This is a member hook
   bs_set_member_hook<> member_hook_;
   MyClass(int i, unsigned int prio)  :  int_(i), prio_(prio)
      {}
   unsigned int get_priority() const
   {  return this->prio_;   }
   //Less and greater operators
   friend bool operator< (const MyClass &a, const MyClass &b)
      {  return a.int_ < b.int_;  }
   friend bool operator> (const MyClass &a, const MyClass &b)
      {  return a.int_ > b.int_;  }
   //Default priority compare
   friend bool priority_order (const MyClass &a, const MyClass &b)
      {  return a.prio_ < b.prio_;  }  //Lower value means higher priority
   //Inverse priority compare
   friend bool priority_inverse_order (const MyClass &a, const MyClass &b)
      {  return a.prio_ > b.prio_;  }  //Higher value means higher priority
};
struct inverse_priority
{
   bool operator()(const MyClass &a, const MyClass &b) const
   {  return priority_inverse_order(a, b); }
};
//Define an treap_set using the base hook that will store values in reverse order
typedef treap_set< MyClass, compare<std::greater<MyClass> > >     BaseSet;
//Define an multiset using the member hook that will store
typedef member_hook<MyClass, bs_set_member_hook<>, &MyClass::member_hook_> MemberOption;
typedef treap_multiset
   < MyClass, MemberOption, priority<inverse_priority> > MemberMultiset;
int main()
{
   typedef std::vector<MyClass>::iterator VectIt;
   //Create several MyClass objects, each one with a different value
   std::vector<MyClass> values;
   for(int i = 0; i < 100; ++i)  values.push_back(MyClass(i, (i % 10)));
   BaseSet baseset;
   MemberMultiset membermultiset;
   //Now insert them in the sets
   for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it){
      baseset.insert(*it);
      membermultiset.insert(*it);
   }
   //Now test treap_sets
   {
      BaseSet::reverse_iterator rbit(baseset.rbegin());
      MemberMultiset::iterator mit(membermultiset.begin());
      VectIt it(values.begin()), itend(values.end());
      //Test the objects inserted in the base hook treap_set
      for(; it != itend; ++it, ++rbit)
         if(&*rbit != &*it)   return 1;
      //Test the objects inserted in the member hook treap_set
      for(it = values.begin(); it != itend; ++it, ++mit)
         if(&*mit != &*it) return 1;
      //Test priority order
      for(int i = 0; i < 100; ++i){
         if(baseset.top()->get_priority() != static_cast<unsigned int>(i/10))
            return 1;
         if(membermultiset.top()->get_priority() != 9u - static_cast<unsigned int>(i/10))
            return 1;
         baseset.erase(baseset.top());
         membermultiset.erase(membermultiset.top());
      }
   }
   return 0;
}