ClassT* obj = FactoryCreate("ClassT"); 

class Object 
{ 
public: 
  virtual string ToString() = 0; 
}; 

class MyClass :public Object 
{ 
public: 
  virtual string ToString(){ return "MyClass"; } 
}; 

Object* FactoryCreat(const string& className) 
{ 
  if (className == "ClassA") 
    return new ClassA; 
  else if (className == "ClassB") 
    return new ClassB; 
  else if(className == "ClassC") 
    return new ClassC; 
  else if(className == "ClassD") 
    return new ClassD; 
  else if(className == "ClassE") 
    return new ClassE; 
  ... 
} 

int main() 
{ 
  Object* obj = FactoryCreat("MyClass"); 
  cout << obj->ToString(); 
  delete obj; 
  return 0; 
} 

//Reflex.h 
class Object 
{ 
public: 
  Object(){} 
  virtual ~Object(){} 
  static bool Register(ClassInfo* ci);     //注册传入一个classInfo(类信息),将这个类的信息注册到映射中 
  static Object* CreateObject(string name);   //工厂生产对象的接口 
}; 

//Reflex.cpp 
static std::map< string, ClassInfo*> *classInfoMap = NULL; 
bool Object::Register(ClassInfo* ci) 
{ 
  if (!classInfoMap)  { 
    classInfoMap = new std::map< string, ClassInfo*>();   //这里我们是通过map来存储这个映射的。 
  } 
  if (ci) { 
    if (classInfoMap->find(ci->m_className) == classInfoMap->end()){ 
      classInfoMap->insert(std::map< string, ClassInfo*>::value_type(ci->m_className, ci)); // 类名 <-> classInfo 
    } 
  } 
  return true; 
} 
Object* Object::CreateObject(std::string name) 
{ 
  std::map< string, ClassInfo*>::const_iterator iter = classInfoMap->find(name); 
  if (classInfoMap->end() != iter) { 
    return iter->second->CreateObject();     //当传入字符串name后,通过name找到info,然后调用对应的CreatObject()即可 
  } 
  return NULL; 
} 

//Reflex.h 
 
typedef Object* (*ObjectConstructorFn)(void); 
class ClassInfo 
{ 
public: 
  ClassInfo(const std::string className, ObjectConstructorFn ctor) 
    :m_className(className), m_objectConstructor(ctor) 
  { 
    Object::Register(this);       //classInfo的构造函数是传入类名和类对应的new函数然后自动注册进map中。 
  } 
  virtual ~ClassInfo(){} 
  Object* CreateObject()const { return m_objectConstructor ? (*m_objectConstructor)() : 0; } 
  bool IsDynamic()const { return NULL != m_objectConstructor; } 
  const std::string GetClassName()const { return m_className; } 
  ObjectConstructorFn GetConstructor()const{ return m_objectConstructor; } 
public: 
  string m_className; 
  ObjectConstructorFn m_objectConstructor; 
}; 

class B : public Object 
{ 
public: 
  B(){ cout << hex << (long)this << " B constructor!" << endl; } 
  ~B(){ cout << hex << (long)this << " B destructor!" << endl; } 
  virtual ClassInfo* GetClassInfo() const{ return &ms_classinfo; } 
  static Object* CreateObject() { return new B; } 
protected: 
  static ClassInfo ms_classinfo; 
}; 
ClassInfo B::ms_classinfo("B", B::CreateObject); 

int main() 
{ 
  Object* obj = Object::CreateObject("B"); 
  delete obj; 
  return 0; 
} 

//Reflex.h 
 
//类申明中添加 classInfo 属性 和 CreatObject、GetClassInfo 方法 
#define DECLARE_CLASS(name) \ 
  protected: \ 
    static ClassInfo ms_classinfo; \ 
  public: \ 
    virtual ClassInfo* GetClassInfo() const; \ 
    static Object* CreateObject(); 
 
//实现CreatObject 和 GetClassInfo 的两个方法 
#define IMPLEMENT_CLASS_COMMON(name,func) \ 
  ClassInfo name::ms_classinfo((#name), \ 
       (ObjectConstructorFn) func); \ 
             \ 
  ClassInfo *name::GetClassInfo() const \ 
    {return &name::ms_classinfo;} 
 
//classInfo 属性的初始化 
#define IMPLEMENT_CLASS(name)      \ 
  IMPLEMENT_CLASS_COMMON(name,name::CreateObject) \ 
  Object* name::CreateObject()          \ 
    { return new name;} 

class B : public Object 
{ 
  DECLARE_CLASS(B) 
public: 
  B(){ cout << hex << (long)this << " B constructor!" << endl; } 
  ~B(){ cout << hex << (long)this << " B destructor!" << endl; } 
}; 
IMPLEMENT_CLASS(B)