Comment concevoir une fabrique d'objets C ++ simple?

En supposant une classe (plugin1) qui hérite de SomeManagerClass, vous avez besoin d'une hiérarchie de classes à construire votre types:

class factory
{
public:
    virtual SomeManagerClass* create() = 0;
};

class plugin1_factory : public factory
{
public:
    SomeManagerClass* create() { return new plugin1(); }
};

Ensuite, vous pouvez affecter ces usines pour un std::map, où ils sont liés à des chaînes

std::map<string, factory*>  factory_map;
...
factory_map["plugin1"] = new plugin1_factory();

Enfin votre TheManager juste besoin de savoir le nom du plugin (comme une chaîne de caractères) et peut retourner un objet de type SomeManagerClass avec juste une ligne de code:

SomeManagerClass* obj = factory_map[plugin_name]->create();

MODIFIER: Si vous n'aimez pas avoir un plugin usine de classe pour chaque plugin, vous pouvez modifier le modèle précédent avec cette:

template <class plugin_type>
class plugin_factory : public factory
{
public:
   SomeManagerClass* create() { return new plugin_type(); }
};

factory_map["plugin1"] = new plugin_factory<plugin1>();

Je pense que c'est une bien meilleure solution. En outre, le 'plugin_factory' classe peut ajouter lui-même à la "factory_map' si tu passes costructor la chaîne.

Je voudrais créer une "base" de l'usine qui a des méthodes virtuelles pour la création de tous les gestionnaires de base, et de laisser le "meta manager" (TheManager dans votre question) prendre un pointeur vers la base de l'usine comme un paramètre de constructeur.

Je suis en supposant que la "fabrique" pouvez personnaliser les instances de CXYZWManager par qui en découlent, mais il est aussi le constructeur de CXYZWManager pourrait prendre différents arguments dans la "coutume" de l'usine.

Un long exemple de code qui affiche "CSomeManager" et "CDerivedFromSomeManager":

#include <iostream>
//--------------------------------------------------------------------------------
class CSomeManager
{
public:
virtual const char * ShoutOut() { return "CSomeManager";}
};
//--------------------------------------------------------------------------------
class COtherManager
{
};
//--------------------------------------------------------------------------------
class TheManagerFactory
{
public:
//Non-static, non-const to allow polymorphism-abuse
virtual CSomeManager   *CreateSomeManager() { return new CSomeManager(); }
virtual COtherManager  *CreateOtherManager() { return new COtherManager(); }
};
//--------------------------------------------------------------------------------
class CDerivedFromSomeManager : public CSomeManager
{
public:
virtual const char * ShoutOut() { return "CDerivedFromSomeManager";}
};
//--------------------------------------------------------------------------------
class TheCustomManagerFactory : public TheManagerFactory
{
public:
virtual CDerivedFromSomeManager        *CreateSomeManager() { return new CDerivedFromSomeManager(); }
};
//--------------------------------------------------------------------------------
class CMetaManager
{
public:
CMetaManager(TheManagerFactory *ip_factory)
: mp_some_manager(ip_factory->CreateSomeManager()),
mp_other_manager(ip_factory->CreateOtherManager())
{}
CSomeManager  *GetSomeManager()  { return mp_some_manager; }
COtherManager *GetOtherManager() { return mp_other_manager; }
private:
CSomeManager  *mp_some_manager;
COtherManager *mp_other_manager;
};
//--------------------------------------------------------------------------------
int _tmain(int argc, _TCHAR* argv[])
{
TheManagerFactory standard_factory;
TheCustomManagerFactory custom_factory;
CMetaManager meta_manager_1(&standard_factory);
CMetaManager meta_manager_2(&custom_factory);
std::cout << meta_manager_1.GetSomeManager()->ShoutOut() << "\n";
std::cout << meta_manager_2.GetSomeManager()->ShoutOut() << "\n";
return 0;
}

Ce semble qu'il serait beaucoup plus simple avec la fonction de template, par opposition à un Résumé de l'Usine modèle

class ManagerFactory
{
public:
template <typename T> static BaseManager * getManager() { return new T();}
};
BaseManager * manager1 = ManagerFactory::template getManager<DerivedManager1>();

Si vous voulez obtenir via une chaîne de caractères, vous pouvez créer une carte standard à partir de chaînes à des pointeurs de fonction. Voici une application qui fonctionne:

#include <map>
#include <string>
class BaseManager
{
public:
virtual void doSomething() = 0;
};
class DerivedManager1 : public BaseManager
{
public:
virtual void doSomething() {};
};
class DerivedManager2 : public BaseManager
{
public:
virtual void doSomething() {};
};
class ManagerFactory
{
public:
typedef BaseManager * (*GetFunction)();
typedef std::map<std::wstring, GetFunction> ManagerFunctionMap;
private:
static ManagerFunctionMap _managers;
public:
template <typename T> static BaseManager * getManager() { return new T();}
template <typename T> static void registerManager(const std::wstring& name)
{
_managers[name] = ManagerFactory::template getManager<T>;
}
static BaseManager * getManagerByName(const std::wstring& name)
{
if(_managers.count(name))
{
return _managers[name]();
}
return NULL;
}
};
//the static map needs to be initialized outside the class
ManagerFactory::ManagerFunctionMap ManagerFactory::_managers;
int _tmain(int argc, _TCHAR* argv[])
{
//you can get with the templated function
BaseManager * manager1 = ManagerFactory::template getManager<DerivedManager1>();
manager1->doSomething();
//or by registering with a string
ManagerFactory::template registerManager<DerivedManager1>(L"Derived1");
ManagerFactory::template registerManager<DerivedManager2>(L"Derived2");
//and getting them
BaseManager * manager2 = ManagerFactory::getManagerByName(L"Derived2");
manager2->doSomething();
BaseManager * manager3 = ManagerFactory::getManagerByName(L"Derived1");
manager3->doSomething();
return 0;
}

MODIFIER: En lisant les autres réponses, j'ai réalisé que ce est très similaire à Dave Van den Eynde FactorySystem solution, mais je suis en utilisant un modèle de fonction pointeur au lieu d'instancier basé sur un modèle de classes usine. Je pense que ma solution est un peu plus léger. En raison des fonctions statiques, le seul objet qui est instanciée est la carte en elle-même. Si vous avez besoin de l'usine pour effectuer d'autres fonctions (DestroyManager, etc.), Je pense que sa solution est plus extensible.

Je voudrais utiliser des modèles comme ça que je peux pas voir le point de fabriques de classes:

class SomeOtherManager;
class SomeManagerClass {
public:
SomeManagerClass(SomeOtherManager*);
virtual void someMethod1();
virtual void someMethod2();
};
class TheBaseManager {
public:
//
};
template <class ManagerClassOne, class ManagerClassOther> 
class SpecialManager : public TheBaseManager {
public:
virtual ManagerClassOne* someManagerClass() const;
virtual ManagerClassOther* someOtherManager() const;
};
TheBaseManager* ourManager = new SpecialManager<SomeManagerClass,SomeOtherManager>;

Mh je ne comprends pas à cent pour cent, et je ne suis pas vraiment dans l'usine des trucs à partir de livres et d'articles.

Si tous vos gestionnaires partagent une même interface vous pourrait dériver d'une classe de base, et l'utilisation de cette classe de base dans votre programme.
Selon l'endroit où la décision qui classe sera créée sera fait, vous devez utiliser un identifiant pour la création (comme indiqué ci-dessus) ou la poignée de la décision du gérant de l'instancier en interne.

Une autre solution serait de mettre en œuvre la "politique" comme à l'aide de modèles. De sorte que Vous ManagerClass::create() renvoie un spécifique SomeOtherManagerWhatever instance. Cela permettrait de poser la décision du gérant à effectuer dans le code qui utilise votre Manager - Maye ce n'est pas prévu.

Ou de cette façon:

template<class MemoryManagment>
class MyAwesomeClass
{
MemoryManagment m_memoryManager;
};

(ou quelque chose comme ça)
Avec cette construction, vous pouvez facilement utiliser d'autres gestionnaires en changeant seulement l'instanciation de MyAwesomeClass.

Aussi Une classe pour cet objet pourrait être un peu plus haut. Dans votre cas, une usine de fonction devrait le faire je pense. Eh bien, c'est plus une question de préférence personnelle.

Vous navez pas parler de TheManager. Il semble que vous souhaitez que le contrôle de la classe est utilisé? ou peut-être essayez-vous à la chaîne d'ensemble?

Il semble que vous besoin d'une classe de base abstraite et un pointeur vers le actuellement utilisés en classe. Si vous souhaitez de la chaîne, vous pouvez le faire dans les deux classe abstraite et themanager classe. Si la classe abstraite, ajouter un membre à la classe suivante dans la chaîne, si themanager puis de les trier dans l'ordre que vous souhaitez utiliser dans la liste. Vous aurez besoin d'un moyen pour ajouter des classes de sorte que vous aurez besoin d'un addMe() dans themanager. Il semble que vous savez ce que vous faites, de sorte w/e que vous choisissez doit être à droite. Une liste avec un addMe func est ma recommandation et si vous voulez seulement 1 classe active alors une fonction dans TheManager de décider qu'il serait bon.

Voici un minimum de modèle de fabrique de mise en œuvre qui m'est venu dans environ 15 minutes. Nous utilisons un similaire qui utilise le plus avancé des classes de base.

#include "stdafx.h"
#include <map>
#include <string>
class BaseClass
{
public:
virtual ~BaseClass() { }
virtual void Test() = 0;
};
class DerivedClass1 : public BaseClass 
{ 
public:
virtual void Test() { } //You can put a breakpoint here to test.
};
class DerivedClass2 : public BaseClass 
{ 
public:
virtual void Test() { } //You can put a breakpoint here to test.
};
class IFactory
{
public:
virtual BaseClass* CreateNew() const = 0;
};
template <typename T>
class Factory : public IFactory
{
public:
T* CreateNew() const { return new T(); }
};
class FactorySystem
{
private:
typedef std::map<std::wstring, IFactory*> FactoryMap;
FactoryMap m_factories;
public:
~FactorySystem()
{
FactoryMap::const_iterator map_item = m_factories.begin();
for (; map_item != m_factories.end(); ++map_item) delete map_item->second;
m_factories.clear();
}
template <typename T>
void AddFactory(const std::wstring& name)
{
delete m_factories[name]; //Delete previous one, if it exists.
m_factories[name] = new Factory<T>();
}
BaseClass* CreateNew(const std::wstring& name) const
{
FactoryMap::const_iterator found = m_factories.find(name);
if (found != m_factories.end())
return found->second->CreateNew();
else
return NULL; //or throw an exception, depending on how you want to handle it.
}
};
int _tmain(int argc, _TCHAR* argv[])
{
FactorySystem system;
system.AddFactory<DerivedClass1>(L"derived1");
system.AddFactory<DerivedClass2>(L"derived2");
BaseClass* b1 = system.CreateNew(L"derived1");
b1->Test();
delete b1;
BaseClass* b2 = system.CreateNew(L"derived2");
b2->Test();
delete b2;
return 0;
}

Il suffit de copier & coller sur une première application console Win32 dans VS2005/2008. Je tiens à souligner quelque chose:

• Vous n'avez pas besoin de créer une usine de béton pour chaque classe. Un modèle qui fera pour vous.
• Je tiens à mettre l'ensemble du modèle de fabrique dans sa propre classe, de sorte que vous n'avez pas besoin de s'inquiéter à propos de la création d'objets de fabrique et de les supprimer. Il vous suffit d'inscrire vos classes, une classe factory est créé par le compilateur et un objet usine est créée par le modèle. À la fin de sa durée de vie, toutes les usines sont proprement détruit. J'aime cette forme d'encapsulation, comme il n'y a aucune confusion sur qui régit la vie des usines.