#include <string>
#include <map>
#include <iostream>
using namespace std;
typedef void* (*Constructor)();
class CObjectFactory
{
    
    
public:
    static void registerClass(std::string className, Constructor constructor)
    {
    
    
        constructors()[className] = constructor;
    }

    static void* createObject(const std::string& className)
    {
    
    
        Constructor constructor = NULL;

        if(constructors().find(className) != constructors().end())
            constructor = constructors().find(className)->second;

        if ( constructor == NULL )
            return NULL;

        return (*constructor)();
    }

private:
    inline static std::map<std::string, Constructor>& constructors()
    {
    
    
        static std::map<std::string, Constructor> instance;
        return instance;
    }
};


#define REGISTER_CLASS(class_name) \
class class_name##Helper { \
public: \
    class_name##Helper() \
    { \
        CObjectFactory::registerClass(#class_name, class_name##Helper::creatObjFunc); \
    } \
    static void* creatObjFunc() \
    { \
        return new class_name; \
    } \
}; \
class_name##Helper class_name##helper;
class base
{
    
    
public:
    virtual void p()=0;
};
class CClassTest: public base{
    
    
public:
    CClassTest(){
    
    cout<<"CClassTest\n";}
    virtual void p(){
    
    cout<<"CClassTest\n";}
};
class CClassTest2:public base{
    
    
public:
    CClassTest2(){
    
    
        cout<<"CClassTest2\n";
    }
    virtual void p(){
    
    cout<<"CClassTest2\n";}
};
REGISTER_CLASS(CClassTest)
REGISTER_CLASS(CClassTest2)
int main()
{
    
    
    base* test = (base*)(CObjectFactory::createObject("CClassTest"));
    base* test2 = (base*)(CObjectFactory::createObject("CClassTest2"));
    test->p();
    test2->p();
    delete test;
    delete test2;
    return 0;
}