Exemple D'Usine Simple:

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

Avez-vous pensé à ne pas utiliser une usine du tout, et à la place faire un bon usage du système de type? Je pense à deux approches différentes qui font ce genre de chose:

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

Qui vous permet d'écrire des choses comme:

Vec2 v(linear(1.0, 2.0));

Option 2:

Vous pouvez utiliser des "tags" comme le fait la STL avec les itérateurs et autres. Par exemple:

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

Cette deuxième approche vous permet d'écrire du code qui ressemble à ceci:

Vec2 v(1.0, 2.0, linear_coord);

Qui est aussi agréable et expressif tout en vous permettant d'avoir des prototypes uniques pour chaque constructeur.

Vous pouvez lire une très bonne solution: http://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

La meilleure solution est sur les "commentaires et discussions", voir le "pas besoin de méthodes de création statiques".

De cette idée, j'ai fait une usine. Notez que J'utilise Qt, mais vous pouvez changer QMap et QString pour les équivalents 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

Exemple d'utilisation:

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

Je suis généralement d'accord avec la réponse acceptée, mais il y a une option C++11 qui n'a pas été couverte dans les réponses existantes:

• renvoie les résultats de la méthode d'usine par valeur , et
• fournir un constructeur move bon marché .

Exemple:

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

Ensuite, vous pouvez construire des objets sur la pile:

sandwich mine{sandwich::ham()};

Comme sous-objets d'autres choses:

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

Ou alloué dynamiquement:

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

Quand pourrais-je utiliser ceci?

Si, sur un constructeur public, il n'est pas possible de donner des initialiseurs significatifs pour tous les membres de la classe sans un calcul préliminaire, alors je pourrais convertir ce constructeur en une méthode statique. La méthode statique effectue les calculs préliminaires, puis renvoie un résultat de valeur via un constructeur privé qui effectue simplement une initialisation par membre.

Je dis ' might ' car cela dépend de l'approche qui donne le code le plus clair sans être inutilement inefficace.

Loki a à la fois un Méthode de Fabrique et Abstract Factory. Les deux sont documentés (largement) dans Modern C++ Design , par Andei Alexandrescu. La méthode factory est probablement plus proche de ce que vous semblez être après, bien qu'elle soit encore un peu différente (au moins si la mémoire sert, elle vous oblige à enregistrer un type avant que l'usine puisse créer des objets de ce type).

Je n'essaie pas de répondre à toutes mes questions, car je crois que c'est trop large. Juste quelques notes:

Il y a des cas où la construction d'objets est une tâche assez complexe pour justifier son extraction vers une autre classe.

Cette classe est en fait un Constructeur, plutôt que d'une Usine.

Dans le cas général, je ne veux pas forcer les utilisateurs de l'usine à être limités à l'allocation dynamique.

, Alors vous pourriez avoir votre usine l'encapsuler dans un pointeur intelligent. Je crois que de cette façon, vous pouvez avoir votre gâteau et le manger aussi.

Cela élimine également les problèmes liés au retour par valeur.

Conclusion: faire une fabrique en retournant un objet est en effet une solution dans certains cas (comme le vecteur 2-D précédemment mentionné), mais pas encore un remplacement général pour les constructeurs.

En effet. Tous les modèles de conception ont leurs contraintes et leurs inconvénients (spécifiques à la langue). Il est recommandé de utilisez-les seulement quand ils vous aident à résoudre votre problème, pas pour eux - mêmes.

Si vous êtes après la mise en œuvre de l'usine" parfaite", Eh bien, bonne chance.

Modèle D'Usine

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

Et si votre compilateur ne prend pas en charge L'optimisation de la valeur de retour, abandonnez-le, il ne contient probablement pas beaucoup d'optimisation du tout...

Je sais que cette question a été répondue il y a 3 ans, mais c'est peut-être ce que vous cherchiez.

Google a publié il y a quelques semaines une bibliothèque permettant des allocations d'objets dynamiques faciles et flexibles. Voici: http://google-opensource.blogspot.fr/2014/01/introducing-infact-library.html

C'est ma solution de style c++11. le paramètre 'base' est pour la classe de base de toutes les sous-classes. les créateurs, sont des objets std::function pour créer des instances de sous-classe, peuvent être une liaison à votre sous-classe' static member function 'create(some args)'. Ce n'est peut-être pas parfait mais fonctionne pour moi. Et c'est un peu le "général" de la solution.

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

Un exemple d'utilisation.

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