#include <iostream>
#include <string>
#include <map>

#define FACTORY_CLASS(classtype) \
extern const char classtype##_name_[] = #classtype; \
class classtype : FactoryBase<classtype,classtype##_name_>

namespace detail_
{
	class registerHelperBase
	{
	public:
		registerHelperBase(){}
	protected:
        static std::map<std::string, void * (*)(void)>& getInitMap() {
            static std::map<std::string, void * (*)(void)>* initMap = 0;
            if(!initMap)
                initMap= new std::map<std::string, void * (*)(void)>();
            return *initMap;
        }
	};

	template<class TParent, const char* ClassName>
	class registerHelper_ : registerHelperBase {
		static registerHelper_ help_;
	public:
        void doNothing(){}
		registerHelper_(){
			getInitMap()[std::string(ClassName)]=&TParent::factory_init_;
		}
	};
	template<class TParent, const char* ClassName>
	registerHelper_<TParent,ClassName> registerHelper_<TParent,ClassName>::help_;
}

class Factory : detail_::registerHelperBase
{
private:
	Factory();
public:
	static void* createObject(const std::string& objclassname) {
		return getInitMap().at(objclassname)();
	}
};


template <class TClass, const char* ClassName>
class FactoryBase {
	private:
		static detail_::registerHelper_<FactoryBase<TClass,ClassName>,ClassName> factory_helper_;
		static void* factory_init_(){ return new TClass();}
	public:
		friend class detail_::registerHelper_<FactoryBase<TClass,ClassName>,ClassName>;
		FactoryBase(){
		    factory_helper_.doNothing();
		}
		virtual ~FactoryBase(){};
};

template <class TClass, const char* ClassName>
detail_::registerHelper_<FactoryBase<TClass,ClassName>,ClassName> FactoryBase<TClass,ClassName>::factory_helper_;


FACTORY_CLASS(Test) {
public:
	Test(){}
};

int main(int argc, char** argv) {
    try {
        Test* test = (Test*) Factory::createObject("Test");
	}
	catch(const std::exception& ex)	{
	    std::cerr << "caught std::exception: "<< ex.what() << std::endl;
	}
	#ifdef _MSC_VER
        system("pause");
	#endif
	return 0;
}