Все контейнеры, предлагаемые Boost.Container, могут хранить только подвижные типы и фактические требования для value_type зависят от каждой операции с контейнером. Следуя требованиям C++11 даже для компиляторов C++03, многие операции теперь требуют подвижных или конструируемых по умолчанию типов вместо просто копируемых конструируемых типов.

Сами контейнеры также являются подвижными, с гарантией отсутствия броска, если операции с выделением или предикатом (если присутствуют) не являются броском. Это позволяет выполнять высокопроизводительные операции при передаче данных между векторами. Давайте посмотрим пример:

#include <boost/container/vector.hpp>
#include <boost/move/utility_core.hpp>
#include <cassert>
//Non-copyable class
class non_copyable
{
   BOOST_MOVABLE_BUT_NOT_COPYABLE(non_copyable)
   public:
   non_copyable(){}
   non_copyable(BOOST_RV_REF(non_copyable)) {}
   non_copyable& operator=(BOOST_RV_REF(non_copyable)) { return *this; }
};
int main ()
{
   using namespace boost::container;
   //Store non-copyable objects in a vector
   vector<non_copyable> v;
   non_copyable nc;
   v.push_back(boost::move(nc));
   assert(v.size() == 1);
   //Reserve no longer needs copy-constructible
   v.reserve(100);
   assert(v.capacity() >= 100);
   //This resize overload only needs movable and default constructible
   v.resize(200);
   assert(v.size() == 200);
   //Containers are also movable
   vector<non_copyable> v_other(boost::move(v));
   assert(v_other.size() == 200);
   assert(v.empty());
   return 0;
}

Все контейнеры, предлагаемые Boost.Container, реализуют вставку размещения, что означает, что объекты могут быть встроены непосредственно в контейнер из аргументов пользователя без создания какого-либо временного объекта. Для компиляторов без вариадных шаблонов поддержка размещения вставки эмулируется до конечного (10) числа аргументов.

Дорогие для перемещения типы являются идеальными кандидатами для размещения функций и в случае контейнеров узлов ( список , набор , ...) место позволяет хранить неподвижные и некопируемые типы в контейнерах! Давайте посмотрим пример:

#include <boost/container/list.hpp>
#include <cassert>
//Non-copyable and non-movable class
class non_copy_movable
{
   non_copy_movable(const non_copy_movable &);
   non_copy_movable& operator=(const non_copy_movable &);
   public:
   non_copy_movable(int = 0) {}
};
int main ()
{
   using namespace boost::container;
   //Store non-copyable and non-movable objects in a list
   list<non_copy_movable> l;
   non_copy_movable ncm;
   //A new element will be built calling non_copy_movable(int) contructor
   l.emplace(l.begin(), 0);
   assert(l.size() == 1);
   //A new element will be value initialized
   l.emplace(l.begin());
   assert(l.size() == 2);
   return 0;
}

Для определения рекурсивных контейнеров можно использовать большинство контейнеров Boost.Container:

#include <boost/container/vector.hpp>
#include <boost/container/stable_vector.hpp>
#include <boost/container/deque.hpp>
#include <boost/container/list.hpp>
#include <boost/container/map.hpp>
#include <boost/container/string.hpp>
using namespace boost::container;
struct data
{
   int               i_;
   //A vector holding still undefined class 'data'
   vector<data>      v_;
   vector<data>::iterator vi_;
   //A stable_vector holding still undefined class 'data'
   stable_vector<data> sv_;
   stable_vector<data>::iterator svi_;
   //A stable_vector holding still undefined class 'data'
   deque<data> d_;
   deque<data>::iterator di_;
   //A list holding still undefined 'data'
   list<data>        l_;
   list<data>::iterator li_;
   //A map holding still undefined 'data'
   map<data, data>   m_;
   map<data, data>::iterator   mi_;
   friend bool operator <(const data &l, const data &r)
   { return l.i_ < r.i_; }
};
struct tree_node
{
   string name;
   string value;
   //children nodes of this node
   list<tree_node>            children_;
   list<tree_node>::iterator  selected_child_;
};
int main()
{
   //a container holding a recursive data type
   stable_vector<data> sv;
   sv.resize(100);
   //Let's build a tree based in
   //a recursive data type
   tree_node root;
   root.name  = "root";
   root.value = "root_value";
   root.children_.resize(7);
   root.selected_child_ = root.children_.begin();
   return 0;
}

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

В этом файле заголовка мы определяем класс (MyClassHolder), который содержит вектор неполного типа (MyClass), который объявлен только вперед.

#include <boost/container/vector.hpp>
//MyClassHolder.h
//We don't need to include "MyClass.h"
//to store vector<MyClass>
class MyClass;
class MyClassHolder
{
   public:
   void AddNewObject(const MyClass &o);
   const MyClass & GetLastObject() const;
   private:
   ::boost::container::vector<MyClass> vector_;
};

Затем мы можем определить MyClass в собственном файле заголовка.

//MyClass.h
class MyClass
{
   private:
   int value_;
   public:
   MyClass(int val = 0) : value_(val){}
   friend bool operator==(const MyClass &l, const MyClass &r)
   {  return l.value_ == r.value_;  }
   //...
};

And include it only in the implementation file of MyClassHolder

//MyClassHolder.cpp
#include "MyClassHolder.h"
//In the implementation MyClass must be a complete
//type so we include the appropriate header
#include "MyClass.h"
void MyClassHolder::AddNewObject(const MyClass &o)
{  vector_.push_back(o);  }
const MyClass & MyClassHolder::GetLastObject() const
{  return vector_.back();  }

Наконец, мы можем просто собрать, связать и запустить!

//Main.cpp
#include "MyClassHolder.h"
#include "MyClass.h"
#include <cassert>
int main()
{
   MyClass mc(7);
   MyClassHolder myclassholder;
   myclassholder.AddNewObject(mc);
   return myclassholder.GetLastObject() == mc ? 0 : 1;
}