Il y a une chose en C ++ qui me met mal à l'aise depuis assez longtemps, car honnêtement, je ne sais pas comment le faire, même si cela semble simple:

Comment implémenter correctement la méthode d'usine en C ++?

Objectif: permettre au client d'instancier un objet en utilisant des méthodes d'usine au lieu des constructeurs de l'objet, sans conséquences inacceptables et sans impact sur les performances.

Par «modèle de méthode d'usine», je veux dire à la fois des méthodes d'usine statiques à l'intérieur d'un objet ou des méthodes définies dans une autre classe, ou des fonctions globales. Généralement, "le concept de redirection de la manière normale d'instanciation de la classe X vers n'importe où ailleurs que le constructeur".

Permettez-moi de parcourir quelques réponses possibles auxquelles j'ai pensé.

0) Ne faites pas d'usines, faites des constructeurs.

Cela semble agréable (et en effet souvent la meilleure solution), mais ce n'est pas un remède général. Tout d'abord, il existe des cas où la construction d'objets est une tâche suffisamment complexe pour justifier son extraction dans une autre classe. Mais même en mettant ce fait de côté, même pour des objets simples utilisant simplement des constructeurs ne suffira pas.

L'exemple le plus simple que je connaisse est une classe de vecteur 2D. Si simple, mais délicat. Je veux pouvoir le construire à la fois à partir des coordonnées cartésiennes et polaires. Évidemment, je ne peux pas faire:

struct Vec2 {
    Vec2(float x, float y);
    Vec2(float angle, float magnitude); // not a valid overload!
    // ...
};

Ma façon de penser naturelle est alors:

struct Vec2 {
    static Vec2 fromLinear(float x, float y);
    static Vec2 fromPolar(float angle, float magnitude);
    // ...
};

Ce qui, au lieu de constructeurs, m'amène à utiliser des méthodes d'usine statiques ... ce qui signifie essentiellement que j'implémente le modèle d'usine, d'une certaine manière ("la classe devient sa propre usine"). Cela a l'air bien (et conviendrait à ce cas particulier), mais échoue dans certains cas, que je vais décrire au point 2. Continuez à lire.

un autre cas: essayer de surcharger par deux typedefs opaques de certaines API (comme les GUID de domaines non liés, ou un GUID et un champ de bits), des types sémantiquement totalement différents (donc - en théorie - des surcharges valides) mais qui s'avèrent en fait être les même chose - comme des entiers non signés ou des pointeurs vides.

1) La voie Java

Java est simple, car nous n'avons que des objets alloués dynamiquement. Faire une usine est aussi trivial que:

class FooFactory {
    public Foo createFooInSomeWay() {
        // can be a static method as well,
        //  if we don't need the factory to provide its own object semantics
        //  and just serve as a group of methods
        return new Foo(some, args);
    }
}

En C ++, cela se traduit par:

class FooFactory {
public:
    Foo* createFooInSomeWay() {
        return new Foo(some, args);
    }
};

Cool? Souvent, en effet. Mais alors, cela oblige l'utilisateur à n'utiliser que l'allocation dynamique. L'allocation statique est ce qui rend le C ++ complexe, mais c'est aussi ce qui le rend souvent puissant. De plus, je pense qu'il existe des cibles (mot-clé: intégré) qui ne permettent pas d'allocation dynamique. Et cela n'implique pas que les utilisateurs de ces plateformes aiment écrire des POO propres.

Quoi qu'il en soit, la philosophie mise à part: dans le cas général, je ne veux pas forcer les utilisateurs de l'usine à être restreints à l'allocation dynamique.

2) Retour par valeur

OK, nous savons donc que 1) est cool quand nous voulons une allocation dynamique. Pourquoi ne pas ajouter une allocation statique en plus de cela?

class FooFactory {
public:
    Foo* createFooInSomeWay() {
        return new Foo(some, args);
    }
    Foo createFooInSomeWay() {
        return Foo(some, args);
    }
};

Quoi? Nous ne pouvons pas surcharger par le type de retour? Oh, bien sûr, nous ne pouvons pas. Modifions donc les noms de méthode pour refléter cela. Et oui, j'ai écrit l'exemple de code invalide ci-dessus juste pour souligner à quel point je n'aime pas la nécessité de changer le nom de la méthode, par exemple parce que nous ne pouvons pas implémenter correctement une conception d'usine indépendante du langage, car nous devons changer les noms - et chaque utilisateur de ce code devra se souvenir de cette différence d'implémentation par rapport à la spécification.

class FooFactory {
public:
    Foo* createDynamicFooInSomeWay() {
        return new Foo(some, args);
    }
    Foo createFooObjectInSomeWay() {
        return Foo(some, args);
    }
};

OK ... nous l'avons. C'est moche, car nous devons changer le nom de la méthode. C'est imparfait, car nous devons écrire deux fois le même code. Mais une fois terminé, cela fonctionne. Droite?

Enfin, d'habitude. Mais parfois non. Lors de la création de Foo, nous dépendons en fait du compilateur pour effectuer l'optimisation de la valeur de retour pour nous, car la norme C ++ est suffisamment bienveillante pour que les fournisseurs du compilateur ne spécifient pas quand l'objet créé en place et quand sera-t-il copié lors du retour d'un objet temporaire par valeur en C ++. Donc, si Foo coûte cher à copier, cette approche est risquée.

Et si Foo n'est pas du tout copiable? Et bien. ( Notez qu'en C ++ 17 avec élision de copie garantie, ne pas être copiable n'est plus un problème pour le code ci-dessus )

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

3) Construction en deux phases

Une autre chose que quelqu'un trouverait probablement est de séparer la question de l'allocation des objets et de son initialisation. Cela se traduit généralement par un code comme celui-ci:

class Foo {
public:
    Foo() {
        // empty or almost empty
    }
    // ...
};

class FooFactory {
public:
    void createFooInSomeWay(Foo& foo, some, args);
};

void clientCode() {
    Foo staticFoo;
    auto_ptr<Foo> dynamicFoo = new Foo();
    FooFactory factory;
    factory.createFooInSomeWay(&staticFoo);
    factory.createFooInSomeWay(&dynamicFoo.get());
    // ...
}

On peut penser que cela fonctionne comme un charme. Le seul prix que nous payons dans notre code ...

Depuis que j'ai écrit tout cela et que je l'ai laissé comme dernier, je dois aussi ne pas l'aimer. :) Pourquoi?

Tout d'abord ... Je n'aime pas sincèrement le concept de construction en deux phases et je me sens coupable quand je l'utilise. Si je conçois mes objets en affirmant que "s'il existe, il est dans un état valide", je pense que mon code est plus sûr et moins sujet aux erreurs. Je l'aime comme ça.

Devoir abandonner cette convention ET changer la conception de mon objet dans le seul but d'en faire une usine est… enfin, lourd.

Je sais que ce qui précède ne convaincra pas beaucoup de gens, alors laissez-moi vous donner quelques arguments plus solides. En utilisant une construction en deux phases, vous ne pouvez pas:

• initialiser constou référencer les variables membres,
• passer des arguments aux constructeurs de classe de base et aux constructeurs d'objets membres.

Et il pourrait probablement y avoir d'autres inconvénients auxquels je ne peux pas penser en ce moment, et je ne me sens même pas particulièrement obligé de le faire car les points ci-dessus me convaincent déjà.

Donc: pas même proche d'une bonne solution générale pour l'implantation d'une usine.

Conclusions:

Nous voulons avoir un moyen d'instanciation d'objet qui:

• permettre une instanciation uniforme quelle que soit l'allocation,
• donner des noms différents et significatifs aux méthodes de construction (donc ne pas compter sur la surcharge par argument),
• ne pas introduire un hit significatif de performance et, de préférence, un hit significatif de ballonnement de code, en particulier côté client,
• être général, comme dans: peut être introduit pour n'importe quelle classe.

Je crois avoir prouvé que les moyens que j'ai mentionnés ne répondent pas à ces exigences.

Des indices? Veuillez me fournir une solution, je ne veux pas penser que ce langage ne me permettra pas de mettre correctement en œuvre un concept aussi trivial.

Tout d'abord, il existe des cas où la construction d'objets est une tâche suffisamment complexe pour justifier son extraction dans une autre classe.

Je pense que ce point est incorrect. La complexité n'a pas vraiment d'importance. La pertinence est ce qui fait. Si un objet peut être construit en une seule étape (pas comme dans le modèle de générateur), le constructeur est le bon endroit pour le faire. Si vous avez vraiment besoin d'une autre classe pour effectuer le travail, il doit quand même s'agir d'une classe auxiliaire utilisée par le constructeur.

Vec2(float x, float y);
Vec2(float angle, float magnitude); // not a valid overload!

Il existe une solution simple pour cela:

struct Cartesian {
  inline Cartesian(float x, float y): x(x), y(y) {}
  float x, y;
};
struct Polar {
  inline Polar(float angle, float magnitude): angle(angle), magnitude(magnitude) {}
  float angle, magnitude;
};
Vec2(const Cartesian &cartesian);
Vec2(const Polar &polar);

Le seul inconvénient est qu'il semble un peu bavard:

Vec2 v2(Vec2::Cartesian(3.0f, 4.0f));

Mais la bonne chose est que vous pouvez immédiatement voir quel type de coordonnées vous utilisez, et en même temps vous n'avez pas à vous soucier de la copie. Si vous voulez copier et que cela coûte cher (comme le prouve le profilage, bien sûr), vous pouvez utiliser quelque chose comme les classes partagées de Qt pour éviter de copier les frais généraux.

Quant au type d'allocation, la principale raison d'utiliser le modèle d'usine est généralement le polymorphisme. Les constructeurs ne peuvent pas être virtuels, et même s'ils le pouvaient, cela n'aurait pas beaucoup de sens. Lorsque vous utilisez une allocation statique ou de pile, vous ne pouvez pas créer d'objets de manière polymorphe car le compilateur doit connaître la taille exacte. Il ne fonctionne donc qu'avec des pointeurs et des références. Et retourner une référence d'une usine ne fonctionne pas non plus, car même si un objet peut techniquement être supprimé par référence, il pourrait être assez déroutant et sujet aux bogues, voir Est-ce que la pratique de renvoyer une variable de référence C ++ est mauvaise?par exemple. Les pointeurs sont donc la seule chose qui reste, et cela inclut également les pointeurs intelligents. En d'autres termes, les usines sont plus utiles lorsqu'elles sont utilisées avec l'allocation dynamique, vous pouvez donc faire des choses comme ceci:

class Abstract {
  public:
    virtual void do() = 0;
};

class Factory {
  public:
    Abstract *create();
};

Factory f;
Abstract *a = f.create();
a->do();

Dans d'autres cas, les usines aident simplement à résoudre des problèmes mineurs comme ceux avec des surcharges que vous avez mentionnés. Ce serait bien s'il était possible de les utiliser de manière uniforme, mais cela ne fait pas grand-chose que c'est probablement impossible.

Exemple simple d'usine:

// 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 du tout une usine et à utiliser plutôt le système de type? Je peux penser à 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) { /* ... */ }
};

Ce qui vous permet d'écrire des choses comme:

Vec2 v(linear(1.0, 2.0));

Option 2:

vous pouvez utiliser des "balises" 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);

ce 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 dans: http://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

La meilleure solution est sur les "commentaires et discussions", voir "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 modifier 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 principalement d'accord avec la réponse acceptée, mais il existe une option C ++ 11 qui n'a pas été couverte dans les réponses existantes:

• Renvoyer les résultats de la méthode d'usine par valeur , et
• Fournir un constructeur de déménagement 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és dynamiquement:

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

Quand pourrais-je l'utiliser?

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 ne fait qu'une initialisation par membre.

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

Loki a à la fois une méthode d'usine et une usine abstraite . Les deux sont documentés (en détail) dans Modern C ++ Design , par Andei Alexandrescu. La méthode d'usine est probablement plus proche de ce que vous semblez rechercher, bien qu'elle soit toujours un peu différente (au moins si la mémoire est bonne, 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 pense que c'est trop large. Juste quelques notes:

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

Cette classe est en fait un constructeur , plutôt qu'une usine.

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

Ensuite, votre usine pourrait 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 rendement par valeur.

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

En effet. Tous les modèles de conception ont leurs contraintes et inconvénients (spécifiques au langage). Il est recommandé de les utiliser uniquement lorsqu'ils vous aident à résoudre votre problème, pas pour eux-mêmes.

Si vous recherchez l'implémentation d'usine "parfaite", alors bonne chance.

Ceci est ma solution de style c ++ 11. le paramètre 'base' est pour la classe de base de toutes les sous-classes. créateurs, sont des objets std :: function pour créer des instances de sous-classe, peuvent être une liaison à votre sous-classe 'fonction membre statique' create (certains arguments) '. Ce n'est peut-être pas parfait mais fonctionne pour moi. Et c'est une solution un peu «générale».

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

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 qu'il a été répondu à cette question 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 simples et flexibles. Le voici: http://google-opensource.blogspot.fr/2014/01/introducing-infact-library.html