动态创建对象

className.cpp

</pre><pre class="cpp" name="code">/** 
实现原理:
    基类里面用map管理所有需要动态创建 【类名-创建对象的函数指针】
    基类声明中需要添加 DECLEAR_DYNCRT_BASE 宏, cpp实现中要添加 IMPLEMENT_DYNCRT_BASE 宏
    
    派生类声明中需要添加 DECLEAR_DYNCRT_CLASS 宏，cpp实现中要添加 IMPLEMENT_DYNCRT_CLASS 宏
    派生类宏中创建了一个全局对象向基类map中注册【类名-创建对象的函数指针】
*/
#include <iostream>
#include <string>
#include <map>
 
using namespace std;
 
// 声明具有动态创建的基类
#define DECLEAR_DYNCRT_BASE(CBase) \
public: \
    typedef CBase *(*ClassGen)(); /* 声明函数指针*/ \
    static CBase *Create(const string &class_name) /* 工厂函数 */ \
    { \
        std::map<string, ClassGen>::iterator iter = m_class_set.find(class_name); \
        if (m_class_set.end() != iter) \
        { \
            return ((*iter).second)(); \
        } \
        return NULL; \
    } \
protected: \
    static void Register(const string &class_name, ClassGen class_gen) /* 注册函数 */ \
    {\
        m_class_set.insert(map<string, ClassGen>::value_type(class_name, class_gen)); \
    } \
    static std::map<string, ClassGen> m_class_set; /* 存储子类信息 */
 
// 用于实现基类
#define IMPLEMENT_DYNCRT_BASE(CBase)  \
    std::map<string, CBase::ClassGen> CBase::m_class_set;
 
// 用于声明一个能够被动态创建的类(用一个全局对象进行注册)
#define DECLEAR_DYNCRT_CLASS(CDerived, CBase) \
public: \
    struct CDerived##Register /* 辅助类，用于注册 */ \
    { \
        CDerived##Register() \
        { \
            static bool bRegistered = false; /* 注册子类，虽然map能保证唯一，但仍只注册一次 */ \
            if(!bRegistered) \
            { \
                CBase::Register(#CDerived, CDerived::Create); /* 注册子类信息 */ \
                bRegistered = true; \
            } \
        } \
    } ; \
    static CBase *Create() /* 工厂函数 */ \
    { \
        return new CDerived; \
    } \
    static struct CDerived##Register m_t##CDerived##Register;
 
// 用于实现一个能被动态创建的类
#define IMPLEMENT_DYNCRT_CLASS(CDerived) \
    static CDerived::CDerived##Register m_t##CDerived##Register;
 
//我们需要做的就是这四个宏
//附加上测试代码：
// 测试实例:
class CBase
{
    DECLEAR_DYNCRT_BASE(CBase)
    DECLEAR_DYNCRT_CLASS(CBase, CBase)
public:
    virtual void Print()
    {
        std::cout << "This is base!" << std::endl;
    }
};
 
IMPLEMENT_DYNCRT_BASE(CBase)
IMPLEMENT_DYNCRT_CLASS(CBase)
 
 
class CDerived : public CBase
{
    DECLEAR_DYNCRT_CLASS(CDerived, CBase)
public:
    virtual void Print()
    {
        cout << "This is derived!" << endl;
    }
};
IMPLEMENT_DYNCRT_CLASS(CDerived)
 
 
int main()
{
    CBase* base = CBase::Create("CDerived");
    if (base)
    {
        cout << "success!";
        base->Print();
    }
    
    //system("pause");
    return 0;
}