C++ Abstract Factory mit Vorlagen

Question

Ich versuche, eine abstrakte Factory-Vorlage für mehrere abstrakte Fabriken in C++ zu erstellen und kam damit auf.

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

Es kompiliert und läuft ohne Speicherlecks (win32 crtdbg) in Ordnung, aber ich weiß nicht, ob dies wirklich der richtige Weg ist eine abstrakte Fabrik Vorlage zu tun.

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

Ich frage mich auch über die Zeile oben. Ich bin verwirrt, warum ich wirken muss. Ich verstehe Vorlagen nicht sehr gut, aber ich würde annehmen, dass es gut funktionieren sollte, wenn man bedenkt, dass sowohl die Template-Klasse als auch die tatsächliche Klasse abgeleitet sind.

Dieser Code funktioniert tatsächlich gut, wie oben gezeigt, und löscht sogar gut ohne Speicherverluste. Ich fühle mich einfach nicht wohl dabei.

ich nicht in der Lage gewesen, mit Ausnahme dieses von Mango keine realen Beispiele von Template-Klassen zu finden (wow Emulator) - https://mangos.svn.sourceforge.net/svnroot/mangos/trunk/src/framework/Dynamic/ObjectRegistry.h

Aber ich glaube nicht, dass ich diese Methode in meinem Projekt verwenden kann, weil ich plane, auf die Verwendung von DLLs an einem bestimmten Punkt in meinem Projekt und es verwendet CRTP, die gegen meine Anforderung für Laufzeitpolymorphismus ist.

Answer 1

Die Klasse DerivedCreator<DerivedA> ist ein Creator<DerivedA> kein Creator<Base>.

Sie müssen der abgeleiteten Vorlage sagen, was die Typ-Basis, so dass es die Schnittstelle von Creator<Base>, indem eine Instanz des abgeleiteten Typs implementieren kann:

// 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

Kleine Bemerkungen das Design zu verbessern: 1) Verwendung shared_ptr statt rohen Zeiger 2) verwenden std :: string statt char *

Sie haben zu werfen, weil Typen Schöpfer, Schöpfer und Schöpfer < DerivedB > sind völlig verschiedene Arten. Die Art und Weise, dies zu beheben ist Abgüsse zu entfernen:

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

Answer 3

Sie Fabrik machen können :: eine Template-Methode registrieren und boost mpl behaupten innen

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