C++動態創建類的實例

寫在前面：首先聲明，C++實際上是不可以動態創建類的實例的。

下面簡單做一個解釋，所謂動態創建類的實例是指在程序運行過程中創建並使用一個“未知”的類。而“未知”是指在程序編譯時並不知道有哪些類是需要動態創建的。對於C++這門語言來說，編譯時不知道的類是不可以在運行時使用的。所以我說C++是不可以的。

不過C++可以做到另一件事情，基本可以滿足大多數類似的需求。

我描述為通過類名稱創建類的實例。

進入正題。

首先描述一下需求：

編寫一個程序實現在程序運行過程中通過類名稱（即字符串變量）創建該類的實例，且在主程序中不出現該類的聲明。

然后進行分析設計：

1.在主程序中不出現類的聲明，還需要用這個類。那很自然就會想到用基類指針實現。

2.創建一個指向該類的基類指針，則需要使用new運算符。

3.通過類名調用相應的new運算符，則需要使用map加函數指針。

4.最后，如何在主函數執行之前構造該map，則需要用到靜態成員在主函數運行前進行創建的機制。

下面給出代碼實現：

首先有一個CObject類作為基類，由它派生出CObjectA和CObjectB兩個需要動態創建的子類。

Object.h

#ifndef __C_OBJECT_H_
#define __C_OBJECT_H_

#include "ObjectFactory.h"

class CObject
{
public:
    CObject(): className("CObject") {}
    virtual ~CObject(){}
    virtual const std::string GetClassName()
    {
        return className;
    }
private:
    std::string className;
};

#endif //__C_OBJECT_H_

ObjectA.h

#ifndef __C_OBJECT_A_H_
#define __C_OBJECT_A_H_

#include "Object.h"

class CObjectA : public CObject
{
public:
    CObjectA(): className("CObjectA") {}
    ~CObjectA(){}
    const std::string GetClassName()
    {
        return className;
    }
private:
    std::string className;
};

REGISTER_CLASS(CObjectA);

#endif //__C_OBJECT_A_H_

ObjectB.h

#ifndef __C_OBJECT_B_H_
#define __C_OBJECT_B_H_

#include "Object.h"

class CObjectB : public CObject
{
public:
    CObjectB(): className("CObjectB") {}
    ~CObjectB(){}
    const std::string GetClassName()
    {
        return className;
    }
private:
    std::string className;
};

REGISTER_CLASS(CObjectB);

#endif //__C_OBJECT_B_H_

然后重點就來了，上面兩個類里面都有的宏定義REGISTER_CLASS。實際上就是聲明一個帶有靜態成員的注冊類，通過初始化該靜態成員實現構造動態創建map。

ObjectFactory.h

#ifndef __C_OBJECT_FACTORY_H_
#define __C_OBJECT_FACTORY_H_

#include <map>
#include <string>

typedef void* (*NewInstancePt)();

class CObjectFactory
{
public:
    static void* CreateObject(const char *className)
    {
        std::map<std::string, NewInstancePt>::const_iterator it;
        it = dynCreateMap.find(className);
        if(it == dynCreateMap.end())
            return NULL;
        else
        {
            NewInstancePt np = it->second;
            return np();
        }
    }

    static void RegisterClass(const char *className, NewInstancePt np)
    {
        dynCreateMap[className] = np;
    }
private:
    static std::map<std::string, NewInstancePt> dynCreateMap;
};

std::map<std::string, NewInstancePt> CObjectFactory::dynCreateMap;

class Register
{
public:
    Register(const char *className, NewInstancePt np)
    {
        CObjectFactory::RegisterClass(className, np);
    }
};

#define REGISTER_CLASS(class_name) \
class class_name##Register \
{ \
public: \
    static void* NewInstance() \
    { \
        return new class_name(); \
    } \
private: \
    static Register reg; \
}; \
Register class_name##Register::reg(#class_name, class_name##Register::NewInstance)

#endif //__C_OBJECT_FACTORY_H_

最后，當然還有如何使用的主函數內容。

RTTI.cpp

#include <stdio.h>
#include "ObjectFactory.h"
#include "Object.h"
#include "ObjectA.h"
#include "ObjectB.h"

int main(int argc, const char *argv[])
{
    CObject *objA = static_cast<CObject *>(CObjectFactory::CreateObject("CObjectA"));
    std::string className;
    if(objA == NULL)
    {
        printf("[ERROR] Can't Create Class ObjectA!\n");
    }
    else
    {
        className = objA->GetClassName();
        printf("[OK] Create %s !\n", className.c_str());
    }

    CObject *objB = static_cast<CObject *>(CObjectFactory::CreateObject("CObjectB"));
    if(objB == NULL)
    {
        printf("[ERROR] Can't Create Class ObjectB!\n");
    }
    else
    {
        className = objB->GetClassName();
        printf("[OK] Create %s !\n", className.c_str());
    }

    return 0;
}

這樣就完成了所謂的動態創建。這里需要注意的是在主函數所在的文件里面需要include所有的需要動態創建的類，否則的話在編譯的過程中這些類以及其注冊類就根本不會被編譯，也就不會構建動態創建map，整個機制也就失效了。這也就是我說的C++實際上是不可以動態創建類的原因。

不得不說，如果想要徹底的動態創建，建議使用Java。簡單看看Java的反射機制和ClassLoader就會知道原來動態加載如此容易。。。