// EntityFactory.h
class EntityFactory
{
public:
    typedef std::map<OBJ_TYPE,EntityFactory*>	FactoryMap;

protected:

    static FactoryMap	m_registry;
    virtual BaseEntity*	Create()=0;

public:
    EntityFactory(OBJ_TYPE _type);
    static BaseEntity*  Construct(OBJ_TYPE _type);

};

// EntityFactory.cpp
EntityFactory::FactoryMap EntityFactory::m_registry;

EntityFactory(OBJ_TYPE _type){
    m_registry.insert(std::make_pair(_type,this));
}

BaseEntity*  Construct(OBJ_TYPE _type){
    EntityFactory::FactoryMap::iterator mapIter = m_registry.find(_type);
    if (mapIter!=EntityFactory::m_registry.end()){
        EntityFactory* pObjectFactory = (*mapIter).second;
        return pObjectFactory->Create();
    }
    else
        return NULL;
}


// Object.h
class Object : public BaseEntity{...};


class ObjectFactory : public EntityFactory
{
public:
    ObjectFactory():EntityFactory(IDC_OBJECT1){}
private:
    BaseEntity* Create() const{
        Object* pObj = NULL;
        try{
            pObj = new Object;
        }
        catch(...){};
        return pObj;
    }

    static const ObjectFactory register_this;
};

//////////////////////////////////////////////////////////////////////////////////  abstract_factory.h///  Allows a user to register types and a key for the type(can be enums ints ///  strings). There are two register functions one which takes a create ///  function which must match the function signature:///  std::auto_ptr<Base> (*func)()///  this allows the user to be able to construct the object in the manner ///  which they require .///  If a create function is not supplied then the default will be used which ///  just returns an auto pointer to the base class./////////  @author Liam Devine, Dan Oppenheim and Richard  Smith (LDR) @date 08/03/2007///////////////////////////////////////////////////////////////////////////////#ifndef ABSTRCT_FACTORY_H_#	define ABSTRCT_FACTORY_H_#	include <map>#	include <string>#	include "types.h"#	include <algorithm>#	include <memory>namespace LDR{	template<typename Base, typename Class>		inline std::auto_ptr<Base> abstract_creater()	{		return std::auto_ptr<Base>(new Class);	}	template<typename Base,typename Id>	class Abstract_factory	{	public:		typedef std::auto_ptr<Base> (*func)();		Abstract_factory(){}		//search the map and look for the create function for this key, if found return the return value		//of the function otherwise return null pointer		std::auto_ptr<Base> create(Id key)		{			iter i;			if(( i = m_creater.find(key) ) != m_creater.end() ){ return  i->second(); }			else			{				throw std::runtime_error("could not find the key in the factory");			}		}		//register a key and a create function for this key		bool register_key(Id key, func function)		{			iter i;			if ( ( i = m_creater.find(key) ) == m_creater.end() )			{				m_creater[key] = function;				return true;			}			else return false;		}		//register a key and supplies the type of class which this key relates to 		//this is then used by the default creater to create the required class		//when called		template <typename Type> bool register_key(Id key)		{			iter i;			if ( ( i = m_creater.find(key) ) == m_creater.end() )			{				m_creater[key] = &abstract_creater<Base,Type>;				return true;			}			else return false;		}		//remove a key and create function from the map		bool unregister_key(Id key)		{			iter i;			if ( ( i = m_creater.find(key) ) == m_creater.end() )			{				m_creater.erase(i);				return true;			}			else return false;		}	private:		std::map< Id , func > m_creater;		typedef typename std::map< Id, func >::iterator iter;	};}#endif//ABSTRCT_FACTORY_H_