Теперь рассмотрим небольшой пример с использованием обоих крючков и обоих контейнеров:

#include <boost/intrusive/unordered_set.hpp>
#include <vector>
#include <functional>
#include <boost/functional/hash.hpp>
using namespace boost::intrusive;
class MyClass : public unordered_set_base_hook<>
{               //This is a derivation hook
   int int_;
   public:
   unordered_set_member_hook<> member_hook_; //This is a member hook
   MyClass(int i)
      :  int_(i)
   {}
   friend bool operator== (const MyClass &a, const MyClass &b)
   {  return a.int_ == b.int_;  }
   friend std::size_t hash_value(const MyClass &value)
   {  return std::size_t(value.int_); }
};
//Define an unordered_set that will store MyClass objects using the base hook
typedef unordered_set<MyClass>    BaseSet;
//Define an unordered_multiset that will store MyClass using the member hook
typedef member_hook<MyClass, unordered_set_member_hook<>, &MyClass::member_hook_>
   MemberOption;
typedef unordered_multiset< MyClass, MemberOption>  MemberMultiSet;
int main()
{
   typedef std::vector<MyClass>::iterator VectIt;
   //Create a vector with 100 different MyClass objects
   std::vector<MyClass> values;
   for(int i = 0; i < 100; ++i)  values.push_back(MyClass(i));
   //Create a copy of the vector
   std::vector<MyClass> values2(values);
   //Create a bucket array for base_set
   BaseSet::bucket_type base_buckets[100];
   //Create a bucket array for member_multi_set
   MemberMultiSet::bucket_type member_buckets[200];
   //Create unordered containers taking buckets as arguments
   BaseSet base_set(BaseSet::bucket_traits(base_buckets, 100));
   MemberMultiSet member_multi_set
      (MemberMultiSet::bucket_traits(member_buckets, 200));
   //Now insert values's elements in the unordered_set
   for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it)
      base_set.insert(*it);
   //Now insert values's and values2's elements in the unordered_multiset
   for(VectIt it(values.begin()), itend(values.end()), it2(values2.begin())
      ; it != itend; ++it, ++it2){
      member_multi_set.insert(*it);
      member_multi_set.insert(*it2);
   }
   //Now find every element
   {
      VectIt it(values.begin()), itend(values.end());
      for(; it != itend; ++it){
         //base_set should contain one element for each key
         if(base_set.count(*it) != 1)           return 1;
         //member_multi_set should contain two elements for each key
         if(member_multi_set.count(*it) != 2)   return 1;
      }
   }
   return 0;
}

Вместо использования класса bucket_traits для хранения массива ковша пользователь может определить свой собственный класс для хранения массива ковша с помощью опции bucket_traits<>. Пользовательские характеристики ковша должны соответствовать следующему интерфейсу:

class my_bucket_traits
{
   bucket_ptr        bucket_begin();
   const_bucket_ptr  bucket_begin() const;
   std::size_t bucket_count() const;
};

Следующие признаки ковша просто хранят указатель на массив ковша, но размер является постоянной времени компиляции. Обратите внимание на использование вспомогательных утилит unordered_bucket и unordered_bucket_ptr для получения типа ведра и его указателя перед определением неупорядоченного контейнера:

#include <boost/intrusive/unordered_set.hpp>
#include <boost/functional/hash.hpp>
#include <vector>
using namespace boost::intrusive;
//A class to be inserted in an unordered_set
class MyClass : public unordered_set_base_hook<>
{
   int int_;
   public:
   MyClass(int i = 0) : int_(i)
   {}
   friend bool operator==(const MyClass &l, const MyClass &r)
      {  return l.int_ == r.int_;   }
   friend std::size_t hash_value(const MyClass &v)
      {  return boost::hash_value(v.int_); }
};
//Define the base hook option
typedef base_hook< unordered_set_base_hook<> >     BaseHookOption;
//Obtain the types of the bucket and the bucket pointer
typedef unordered_bucket<BaseHookOption>::type     BucketType;
typedef unordered_bucket_ptr<BaseHookOption>::type BucketPtr;
//The custom bucket traits.
class custom_bucket_traits
{
   public:
   static const int NumBuckets = 100;
   custom_bucket_traits(BucketPtr buckets)
      :  buckets_(buckets)
   {}
   //Functions to be implemented by custom bucket traits
   BucketPtr   bucket_begin() const {  return buckets_;  }
   std::size_t bucket_count() const {  return NumBuckets;}
   private:
   BucketPtr buckets_;
};
//Define the container using the custom bucket traits
typedef unordered_set<MyClass, bucket_traits<custom_bucket_traits> > BucketTraitsUset;
int main()
{
   typedef std::vector<MyClass>::iterator VectIt;
   std::vector<MyClass> values;
   //Fill values
   for(int i = 0; i < 100; ++i)  values.push_back(MyClass(i));
   //Now create the bucket array and the custom bucket traits object
   BucketType buckets[custom_bucket_traits::NumBuckets];
   custom_bucket_traits btraits(buckets);
   //Now create the unordered set
   BucketTraitsUset uset(btraits);
   //Insert the values in the unordered set
   for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it)
      uset.insert(*it);
   return 0;
}