Шаблон boost::factory позволяет инкапсулировать new выражение как объект функции, boost:: value_factory инкапсулирует конструктора без new.

boost::factory<T*>()(arg1,arg2,arg3)
// same as new T(arg1,arg2,arg3)
boost::value_factory<T>()(arg1,arg2,arg3)
// same as T(arg1,arg2,arg3)

По техническим причинам аргументы для функциональных объектов должны быть LValues. Фабрика, которая также принимает RValues, может быть составлена с использованием boost::forward_adapter или boost::bind>.

В традиционном ориентированном на объект программировании фабрика является объектом, реализующим интерфейс одного или нескольких методов, которые строят объекты, соответствующие известным интерфейсам.

// assuming a_concrete_class and another_concrete_class are derived
// from an_abstract_class
class a_factory
{
  public:
    virtual an_abstract_class* create() const = 0;
    virtual ~a_factory() { }
};
class a_concrete_factory : public a_factory
{
  public:
    virtual an_abstract_class* create() const
    {
        return new a_concrete_class();
    }
};
class another_concrete_factory : public a_factory
{
  public:
    virtual an_abstract_class* create() const
    {
        return new another_concrete_class();
    }
};
// [...]
int main()
{
    boost::ptr_map<std::string,a_factory> factories;
    // [...]
    factories.insert("a_name",std::auto_ptr<a_factory>(
        new a_concrete_factory));
    factories.insert("another_name",std::auto_ptr<a_factory>(
        new another_concrete_factory));
    // [...]
    std::auto_ptr<an_abstract_class> x(factories.at(some_name).create());
    // [...]
}

Этот подход имеет несколько недостатков. Самым очевидным является то, что существует множество котел-кодов. Другими словами, существует слишком много кода, чтобы выразить довольно простое намерение. Мы могли бы использовать шаблоны, чтобы избавиться от некоторых из них, но подход остается негибким:

Опыт показал, что использование функциональных объектов и общих компонентов Boost для их состава, Design Patterns, которые описывают механизмы обратного вызова (как правило, требующий высокого процента котел-кода с чистой методологией объект-ориентированной) становятся реализуемыми с помощью всего нескольких строк кода и без дополнительных классов.

Фабрики - это механизмы обратного вызова для конструкторов, поэтому мы предоставляем два шаблона класса: boost:: value_factory и boost::factory, которые инкапсулируют конструкцию объекта путем прямого применения конструктора и new оператора, соответственно.

Мы позволяем функциям направлять свои аргументы в пользу выражений, которые они инкапсулируют. Над этим boost::фабрикатор опционально позволяет использовать умные указатели и Аллократы.

Полиморфизм комбинированного времени может использоваться там, где это необходимо,

template< class T >
void do_something()
{
    // [...]
    T x = T(a,b);
    // for conceptually similar objects x we neither need virtual
    // functions nor a common base class in this context.
    // [...]
}

Теперь, чтобы разрешить неоднородные подписи для конструкторов типов, переданных для T, мы можем использовать value_factory и boost::bind для нормализации между ними.

template< class ValueFactory >
void do_something(ValueFactory make_obj = ValueFactory())
{
    // [...]
    typename ValueFactory::result_type x = make_obj(a,b);
    // for conceptually similar objects x we neither need virtual
    // functions nor a common base class in this context.
    // [...]
}
int main()
{
    // [...]
    do_something(boost::value_factory<X>());
    do_something(boost::bind(boost::value_factory<Y>(),_1,5,_2));
    // construct X(a,b) and Y(a,5,b), respectively.
    // [...]
}

template< class Factory >
whatever do_something(Factory new_obj = Factory())
{
    typename Factory::result_type ptr = new_obj(a,b);
    // again, no common base class or virtual functions needed,
    // we could enforce a polymorphic base by writing e.g.
    //    boost::shared_ptr<base>
    // instead of
    //    typename Factory::result_type
    // above.
    // Note that we are also free to have the type erasure happen 
    // somewhere else (e.g. in the constructor of this function's
    // result type).
    // [...]
}
// [... call do_something like above but with __factory__ instead
// of __value_factory__]

typedef boost::function< an_abstract_class*() > a_factory;
// [...]
int main()
{
    std::map<std::string,a_factory> factories;
    // [...]
    factories["a_name"] = boost::factory<a_concrete_class*>();
    factories["another_name"] =
        boost::factory<another_concrete_class*>();
    // [...]
}