Простой Заводской Пример:

// Factory returns object and ownership
// Caller responsible for deletion.
#include <memory>
class FactoryReleaseOwnership{
  public:
    std::unique_ptr<Foo> createFooInSomeWay(){
      return std::unique_ptr<Foo>(new Foo(some, args));
    }
};

// Factory retains object ownership
// Thus returning a reference.
#include <boost/ptr_container/ptr_vector.hpp>
class FactoryRetainOwnership{
  boost::ptr_vector<Foo>  myFoo;
  public:
    Foo& createFooInSomeWay(){
      // Must take care that factory last longer than all references.
      // Could make myFoo static so it last as long as the application.
      myFoo.push_back(new Foo(some, args));
      return myFoo.back();
    }
};

вы думали о том, чтобы вообще не использовать завод, а вместо этого хорошо использовать систему типов? Я могу думать о двух разных подходах, которые делают такие вещи:

Вариант 1:

struct linear {
    linear(float x, float y) : x_(x), y_(y){}
    float x_;
    float y_;
};

struct polar {
    polar(float angle, float magnitude) : angle_(angle),  magnitude_(magnitude) {}
    float angle_;
    float magnitude_;
};


struct Vec2 {
    explicit Vec2(const linear &l) { /* ... */ }
    explicit Vec2(const polar &p) { /* ... */ }
};

что позволяет вам писать такие вещи, как:

Vec2 v(linear(1.0, 2.0));

Вариант 2:

вы можете использовать "теги", как STL делает с итераторами и такими. Например:

struct linear_coord_tag linear_coord {}; // declare type and a global
struct polar_coord_tag polar_coord {};

struct Vec2 {
    Vec2(float x, float y, const linear_coord_tag &) { /* ... */ }
    Vec2(float angle, float magnitude, const polar_coord_tag &) { /* ... */ }
};

этот второй подход позволяет писать код который выглядит так:

Vec2 v(1.0, 2.0, linear_coord);

что также приятно и выразительно, позволяя вам иметь уникальные прототипы для каждого конструктора.

вы можете прочитать очень хорошее решение в: http://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

лучшее решение находится в разделе "комментарии и обсуждения", см. "нет необходимости в статических методах создания".

от этой идеи, я сделал завод. Обратите внимание, что я использую Qt, но вы можете изменить qmap и QString для эквивалентов std.

#ifndef FACTORY_H
#define FACTORY_H

#include <QMap>
#include <QString>

template <typename T>
class Factory
{
public:
    template <typename TDerived>
    void registerType(QString name)
    {
        static_assert(std::is_base_of<T, TDerived>::value, "Factory::registerType doesn't accept this type because doesn't derive from base class");
        _createFuncs[name] = &createFunc<TDerived>;
    }

    T* create(QString name) {
        typename QMap<QString,PCreateFunc>::const_iterator it = _createFuncs.find(name);
        if (it != _createFuncs.end()) {
            return it.value()();
        }
        return nullptr;
    }

private:
    template <typename TDerived>
    static T* createFunc()
    {
        return new TDerived();
    }

    typedef T* (*PCreateFunc)();
    QMap<QString,PCreateFunc> _createFuncs;
};

#endif // FACTORY_H

пример использования:

Factory<BaseClass> f;
f.registerType<Descendant1>("Descendant1");
f.registerType<Descendant2>("Descendant2");
Descendant1* d1 = static_cast<Descendant1*>(f.create("Descendant1"));
Descendant2* d2 = static_cast<Descendant2*>(f.create("Descendant2"));
BaseClass *b1 = f.create("Descendant1");
BaseClass *b2 = f.create("Descendant2");

Я в основном согласен с принятым ответом, но есть вариант C++11, который не был охвачен в существующих ответах:

• возврат результатов Заводского метода по стоимости и
• обеспечить дешевые переместить конструктор.

пример:

struct sandwich {
  // Factory methods.
  static sandwich ham();
  static sandwich spam();
  // Move constructor.
  sandwich(sandwich &&);
  // etc.
};

затем вы можете построить объекты в стеке:

sandwich mine{sandwich::ham()};

как подобъекты других вещей:

auto lunch = std::make_pair(sandwich::spam(), apple{});

или динамически выделено:

auto ptr = std::make_shared<sandwich>(sandwich::ham());

когда я могу это использовать?

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

Я говорю 'может' потому что это зависит на какой подход дает самый ясный код, не будучи излишне неэффективным.

у Локи есть оба Метод Фабрики и Абстрактная Фабрика. Оба они документированы (широко) в Современный Дизайн C++, по Андрей Александреску. Фабричный метод, вероятно, ближе к тому, что вы, кажется, после, хотя это все еще немного отличается (по крайней мере, если память служит, он требует, чтобы вы зарегистрировали тип, прежде чем фабрика может создавать объекты этого типа).

Я не пытаюсь ответить на все мои вопросы, так как я считаю, что это слишком широко. Всего пара заметок:

бывают случаи, когда построение объекта является достаточно сложной задачей для обоснования его извлечения в другой класс.

этот класс на самом деле a Строитель, а не завод.

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

тогда вы могли бы иметь свой завод инкапсулировать его в умный указатель. Я считаю, что таким образом вы можете иметь свой торт и съесть его тоже.

Это также исключает проблемы, связанные с возвратом по значению.

вывод: создание фабрики путем возврата объекта действительно является решением для некоторых случаев (таких как 2-D вектор, упомянутый ранее), но все же не является общей заменой для конструкторов.

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

Если вы после "идеальной" реализации завода, ну, удачи.

Шаблон Фабрики

class Point
{
public:
  static Point Cartesian(double x, double y);
private:
};

и если компилятор не поддерживает оптимизацию возвращаемого значения, отбросьте его, он, вероятно, вообще не содержит много оптимизации...

Я знаю, что на этот вопрос был дан ответ 3 года назад, но это может быть то, что вы искали.

Google выпустила пару недель назад библиотеку, позволяющую легко и гибко распределять динамические объекты. Вот оно:http://google-opensource.blogspot.fr/2014/01/introducing-infact-library.html

Это мое решение стиля c++11. параметр 'base' предназначен для базового класса всех подклассов. создатели, являются объектами std::function для создания экземпляров подкласса, могут быть привязкой к вашему подклассу "статическая функция-член" create(some args)". Это может быть не идеально, но работает для меня. И это своего рода "общее" решение.

template <class base, class... params> class factory {
public:
  factory() {}
  factory(const factory &) = delete;
  factory &operator=(const factory &) = delete;

  auto create(const std::string name, params... args) {
    auto key = your_hash_func(name.c_str(), name.size());
    return std::move(create(key, args...));
  }

  auto create(key_t key, params... args) {
    std::unique_ptr<base> obj{creators_[key](args...)};
    return obj;
  }

  void register_creator(const std::string name,
                        std::function<base *(params...)> &&creator) {
    auto key = your_hash_func(name.c_str(), name.size());
    creators_[key] = std::move(creator);
  }

protected:
  std::unordered_map<key_t, std::function<base *(params...)>> creators_;
};

пример использования.

class base {
public:
  base(int val) : val_(val) {}

  virtual ~base() { std::cout << "base destroyed\n"; }

protected:
  int val_ = 0;
};

class foo : public base {
public:
  foo(int val) : base(val) { std::cout << "foo " << val << " \n"; }

  static foo *create(int val) { return new foo(val); }

  virtual ~foo() { std::cout << "foo destroyed\n"; }
};

class bar : public base {
public:
  bar(int val) : base(val) { std::cout << "bar " << val << "\n"; }

  static bar *create(int val) { return new bar(val); }

  virtual ~bar() { std::cout << "bar destroyed\n"; }
};

int main() {
  common::factory<base, int> factory;

  auto foo_creator = std::bind(&foo::create, std::placeholders::_1);
  auto bar_creator = std::bind(&bar::create, std::placeholders::_1);

  factory.register_creator("foo", foo_creator);
  factory.register_creator("bar", bar_creator);

  {
    auto foo_obj = std::move(factory.create("foo", 80));
    foo_obj.reset();
  }

  {
    auto bar_obj = std::move(factory.create("bar", 90));
    bar_obj.reset();
  }
}