C++ Abstract Usine utilisant des modèles

Question

J'essaie de créer un modèle d'usine abstrait pour plusieurs usines abstraites en C++ et est venu avec cela.

#define _CRTDBG_MAP_ALLOC 
#include <crtdbg.h> 
#include <map> 
#include <stdio.h> 

class Base 
{ 
public: 
    virtual ~Base() {} 

    virtual bool Get() = 0; 
}; 

class DerivedA : public Base 
{ 
public: 
    bool Get() 
    { 
     return true; 
    } 
}; 

class DerivedB : public Base 
{ 
public: 
    bool Get() 
    { 
     return false; 
    } 
}; 

template <class T> 
class Creator 
{ 
public: 
    virtual ~Creator(){} 
    virtual T* Create() = 0; 
}; 

template <class T> 
class DerivedCreator : public Creator<T> 
{ 
public: 
    T* Create() 
    { 
     return new T; 
    } 
}; 

template <class T, class Key> 
class Factory 
{ 
public: 
    void Register(Key Id, Creator<T>* Fn) 
    { 
     FunctionMap[Id] = Fn; 
    } 

    T* Create(Key Id) 
    { 
     return FunctionMap[Id]->Create(); 
    } 

    ~Factory() 
    { 
     std::map<Key, Creator<T>*>::iterator i = FunctionMap.begin(); 
     while (i != FunctionMap.end()) 
     { 
      delete (*i).second; 
      ++i; 
     } 
    } 
private: 
    std::map<Key, Creator<T>*> FunctionMap; 
}; 

int main(int argc, char** argv[]) 
{ 
    _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF); 

    //Register 
    Factory<Base, char*> temp; 
    temp.Register("DA", (Creator<Base>*)new DerivedCreator<DerivedA>); 
    temp.Register("DB", (Creator<Base>*)new DerivedCreator<DerivedB>); 

    //Pointer to base interface 
    Base* pBase = 0; 

    //Create and call 
    pBase = temp.Create("DA"); 
    printf("DerivedA %u\n", pBase->Get()); 
    delete pBase; 

    //Create and call 
    pBase = temp.Create("DB"); 
    printf("DerivedB %u\n", pBase->Get()); 
    delete pBase; 

return 0; 
} 

Il compile et fonctionne très bien sans fuites de mémoire (win32 crtdbg) mais je ne sais pas si cela est vraiment la bonne façon de faire un modèle de fabrique abstraite.

temp.Register("DA", (Creator<Base>*)new DerivedCreator<DerivedA>); 

Je m'interroge également sur la ligne ci-dessus. Je suis confus pourquoi je dois lancer. Je ne comprends pas très bien les modèles, mais je suppose que cela devrait fonctionner correctement, étant donné que la classe template et la classe réelle sont dérivées.

Ce code fonctionne réellement bien comme indiqué ci-dessus et supprime même bien sans fuites de mémoire. Je ne me sens tout simplement pas à l'aise avec ça.

Je n'ai pas pu trouver de véritables exemples de classes de modèle, sauf pour ce billet depuis MaNGOS (wow émulateur) - https://mangos.svn.sourceforge.net/svnroot/mangos/trunk/src/framework/Dynamic/ObjectRegistry.h

Mais je ne pense pas que je peux utiliser cette méthode dans mon projet parce que je prévois sur l'utilisation des DLL à un moment donné dans mon projet et il utilise CRTP qui est contre mon exigence pour le polymorphisme d'exécution.

Answer 1

La classe DerivedCreator<DerivedA> est un Creator<DerivedA> pas Creator<Base>.

Vous devez dire le modèle dérivé que soit le type de base pour qu'il puisse mettre en œuvre l'interface de Creator<Base> en créant une instance de type dérivé:

// DerivedCreator is Creator<BaseType> which creates a 
// DerivedType, not a Creator<DerivedType> 
template <class DerivedType, class BaseType> 
class DerivedCreator : public Creator<BaseType> 
{ 
public: 
    BaseType* Create() 
    { 
     return new DerivedType; 
    } 
}; 

// Register 
Factory<Base, std::string> temp; 
temp.Register("DA", new DerivedCreator<DerivedA, Base>); 
temp.Register("DB", new DerivedCreator<DerivedB, Base>); 

// or if you want to create lots with the same base: 
template <class DerivedType> 
class DerivedBaseCreator : public DerivedCreator<DerivedType, Base> {}; 

//Register 
Factory<Base, std::string> temp; 
temp.Register("DA", new DerivedBaseCreator<DerivedA>); 
temp.Register("DB", new DerivedBaseCreator<DerivedB>); 

Answer 2

Remarques petites pour améliorer la conception: 1) Utiliser shared_ptr au lieu des pointeurs premières 2) utiliser std :: string au lieu de char *

Vous devez jeter, car les types Créateur, Créateur et créateur < DerivedB > sont des types complètement différents. La façon de résoudre ce problème est d'éliminer les moulages:

//Register 
Factory<Base, char*> temp; 
temp.Register("DA", new DerivedCreator<Base>); 
temp.Register("DB", new DerivedCreator<Base>); 

Answer 3

Vous pouvez faire usine :: enregistrer une méthode de modèle et d'utiliser l'amplification mpl affirment l'intérieur

#include <boost/mpl/assert.hpp> 
#include <boost/type_traits.hpp> 

template <class T, class Key> 
class Factory 
{ 
public: 
/////////////////////////////////// 
template <typename _Base> 
void Register(Key Id, Creator<_Base> * Fn) 
{ 
    BOOST_MPL_ASSERT((boost::is_base_of<T, _Base>)); 

    FunctionMap[Id] = reinterpret_cast<Creator<T>*>(Fn); 
} 
/////////////////////////////////// 
//... 
};