C++ 中泛型工厂注册类的实现

//C++ 中泛型工厂注册类的实现

//---------------------------------------------------------------------------

#ifndef GenericFactoryH
#define GenericFactoryH

#include <string>
#include <map>

#define REGISTER_CLASS(BASE_CLASS, DERIVED_CLASS)/
RegisterInpFactory<BASE_CLASS, DERIVED_CLASS> Register##DERIVED_CLASS(#DERIVED_CLASS)

#define CREATE_CLASS(BASE_CLASS,DERIVED_CLASS)/
GenericFactory<BASE_CLASS>::instance().Create(#DERIVED_CLASS)

//---------------------------------------------------------------------------
using std::string;
using std::map;

template <class ManufacturedType, typename ClassIDKey=std::string>
class GenericFactory
{
typedef ManufacturedType* (*BaseCreateFn)();

typedef std::map<ClassIDKey, BaseCreateFn> FnRegistry;

FnRegistry registry;

GenericFactory() {}

GenericFactory(const GenericFactory&) {} // 没有实现

GenericFactory &operator=(const GenericFactory&) {} // 没有实现

public:
static GenericFactory& instance()
{
static GenericFactory<ManufacturedType,ClassIDKey> bf;
return bf;
}

void RegCreateFn(const ClassIDKey &classname, BaseCreateFn fn)
{
registry[classname] = fn;
}

ManufacturedType* Create(const ClassIDKey &classname) const
{
ManufacturedType* theObject(0);
FnRegistry::const_iterator regEntry = registry.find(classname);
if (regEntry != registry.end())
{
theObject = regEntry->second();
}
return theObject;
}
};

template <class AncestorType, class ManufacturedType, typename ClassIDKey=std::string>
class RegisterInpFactory
{
public:
static AncestorType* CreateInstance()
{
return (new ManufacturedType);
}
RegisterInpFactory(const ClassIDKey &id)
{
GenericFactory<AncestorType,ClassIDKey>::instance().RegCreateFn(id, CreateInstance);
}
};

#endif