Prosty Przykład Fabryczny:

// 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();
    }
};

Czy myślałeś o tym, aby w ogóle nie używać fabryki, a zamiast tego dobrze korzystać z systemu typów? Mogę myśleć o dwóch różnych podejściach, które robią tego typu rzeczy:

Opcja 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) { /* ... */ }
};

Który pozwala pisać takie rzeczy jak:

Vec2 v(linear(1.0, 2.0));

Opcja 2:

Możesz używać "tagów", tak jak STL robi to z iteratorami itp. Na przykład:

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 &) { /* ... */ }
};

To drugie podejście pozwala napisać kod, który wygląda tak:

Vec2 v(1.0, 2.0, linear_coord);

Który jest również ładne i wyraziste, a jednocześnie pozwala mieć unikalne prototypy dla każdego konstruktora.

Możesz przeczytać bardzo dobre rozwiązanie w: http://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

Najlepszym rozwiązaniem jest "komentarze i dyskusje", Patrz "nie ma potrzeby tworzenia statycznych metod".

#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

Przykładowe użycie:

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");

W większości zgadzam się z zaakceptowaną odpowiedzią, ale istnieje opcja C++11, która nie została uwzględniona w istniejących odpowiedziach:

• zwraca wyniki metody fabrycznej według wartości i
• Zapewnij Tani konstruktor ruchu .

Przykład:

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

Następnie można konstruować obiekty na stosie:

sandwich mine{sandwich::ham()};

Jako podobiekty innych rzeczy:

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

Lub przydzielane dynamicznie:

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

Jeśli, na konstruktor publiczny, nie jest możliwe podanie sensownych inicjalizatorów dla wszystkich członków klasy bez wstępnego obliczenia, wtedy mogę przekonwertować ten konstruktor na statyczną metodę. Metoda statyczna wykonuje wstępne obliczenia, a następnie zwraca wynik wartości za pomocą prywatnego konstruktora, który po prostu inicjalizuje elementy składowe.

Mówię "Może ", ponieważ zależy to od tego, które podejście daje najczystszy kod, nie będąc niepotrzebnie nieefektywnym.

Loki ma zarówno metodę Factory , jak i Abstract Factory . Oba są udokumentowane (obszernie) w Modern C++ Design, przez Andei Alexandrescu. Metoda factory jest prawdopodobnie bliższa temu, co wydaje się być po, choć nadal jest nieco inna (przynajmniej jeśli pamięć służy, wymaga zarejestrowania typu, zanim fabryka będzie mogła tworzyć obiekty tego typu).

Nie staram się odpowiadać na wszystkie moje pytania, ponieważ uważam, że jest zbyt szeroka. Tylko kilka uwag:

Są przypadki, gdy budowa obiektu jest zadaniem na tyle złożonym, aby uzasadnić jego ekstrakcję do innej klasy.

Ta klasa jest w rzeczywistości budowniczym , a nie fabryką.

W ogólnym przypadku nie chcę zmuszać użytkowników fabryki do ograniczenia dynamicznej alokacji.

Wtedy możesz mieć swoją fabrykę zamknijcie go w inteligentnym wskaźniku. Wierzę, że w ten sposób możesz zjeść swoje ciasto i je zjeść.

Eliminuje to również problemy związane z zwracaniem wartości.

Wniosek: utworzenie fabryki poprzez zwrócenie obiektu jest rzeczywiście rozwiązaniem w niektórych przypadkach (np. wektor 2-D wcześniej wspomniany), ale nadal nie jest ogólnym zamiennikiem dla konstruktorów.

W rzeczy samej. Wszystkie wzorce projektowe mają swoje ograniczenia i wady (specyficzne dla języka). Zaleca się używaj ich tylko wtedy, gdy pomogą Ci rozwiązać twój problem, a nie dla ich własnego dobra.

Jeśli jesteś po" idealne " wdrożenie fabryki, cóż, powodzenia.

Wzór Fabryczny

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

A jeśli kompilator nie obsługuje optymalizacji zwracanej wartości, porzuć ją, prawdopodobnie w ogóle nie zawiera zbyt wiele optymalizacji...

Wiem, że odpowiedź na to pytanie została udzielona 3 lata temu, ale to może być to, czego szukaliście.

Google udostępniło kilka tygodni temu bibliotekę umożliwiającą łatwe i elastyczne dynamiczne przydzielanie obiektów. Oto on: http://google-opensource.blogspot.fr/2014/01/introducing-infact-library.html

To moje rozwiązanie w stylu c++11. parametr "base" jest dla klasy bazowej wszystkich podklas. creators, are STD:: function objects to create sub-class instances, may be a binding to your sub-class 'static member function' create (some args)'. To może nie jest idealne, ale działa dla mnie. I jest to rozwiązanie "ogólne".

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_;
};

Przykład użycia.

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();
  }
}