04.C++反射的实现

 

C++本身是没有反射机制的，但C#和JAVA等语言内置反射机制。
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

通俗点讲，反射侧重于在执行过程中对于程序状态数据的操纵能力。表现在内省和调解两个方面：
内省：是程序观察进而解释自身状态的能力。
调解：是程序修改其执行状态或修改自身含义的能力。

而为什么需要反射呢？
当需要编写扩展性较强的代码、处理在程序设计师并不确定的对象时，反射机制会展示其威力。如：
1.序列化（Serialization）和数据绑定（Data Binding）。
2.远程方法调用（Remote Method Invocation，RMI）。
3.对象/关系数据映射（E/R Mapping）。
比如Web服务器中的servlet，通常需要使用哪个servlet来处理客户端的请求，是根据servlet的名字字符串来指定的要调用哪个servlet的，这应该就需要用到反射。
MFC中也到处存在该技术的影子。

简单实现C++反射的思路：
定义一组描述类型信息的辅助类，在程序中手工添加一系列宏定义，用来描述类型信息，实例化相关的辅助描述类，在运行时就可以使用辅助类来实现反射的功能。下面看这个思路的具体实现代码：

// ReflectFactory.h

#pragma once
#include <string>

typedef void* (*lpCreateInstanceFun)();
typedef struct tagClassInfoData
{
    std::string strClassName;
    lpCreateInstanceFun pFun;
    tagClassInfoData* pNext;
}ClassInfoData;

class CReflectFactory
{
private:
    static ClassInfoData* pData;
    static ClassInfoData* pHead;
    static CReflectFactory _tmp_;

public:
    CReflectFactory(void);
    ~CReflectFactory(void);
    static void AddInstance(const std::string& strClassName, lpCreateInstanceFun pFun);
    static void* GetInstance(const std::string& strClassName);
};

#define DECLARE_REFLECT(CLASS_NAME) private:\
    static void* _CreateInstance_(){ return new CLASS_NAME(); }\
    static wchar_t _m_AddFunc_;\
    static wchar_t _AddFunc_() { CReflectFactory::AddInstance(#CLASS_NAME, &_CreateInstance_); return 0; }

#define IMPLEMENT_REFLECT(CLASS_NAME) wchar_t CLASS_NAME::_m_AddFunc_ = _AddFunc_();

// ReflectFactory.cpp

#include ".\ReflectFactory.h"

ClassInfoData* CReflectFactory::pData = NULL;
ClassInfoData* CReflectFactory::pHead = NULL;
CReflectFactory CReflectFactory::_tmp_;

CReflectFactory::CReflectFactory(void)
{
}

CReflectFactory::~CReflectFactory(void)
{
    ClassInfoData* pFind = pHead;
    while ( pFind != NULL )
    {
        pFind = pHead->pNext;
        delete pHead;
        pHead = pFind;
    }
}

void CReflectFactory::AddInstance(const std::string& strClassName, lpCreateInstanceFun pFun)
{
    if ( NULL != pFun )
    {
        if ( NULL == pData )
        {
            pData = new ClassInfoData();
            pHead = pData;
        }
        else
        {
            pData->pNext = new ClassInfoData();
            pData = pData->pNext;
        }
        pData->strClassName = strClassName;
        pData->pFun = pFun;
        pData->pNext = NULL;
    }
}

void* CReflectFactory::GetInstance(const std::string& strClassName)
{
    std::string str = strClassName;
    ClassInfoData* pFind = pHead;
    while ( pFind != NULL )
    {
        if ( str == pFind->strClassName )
        {
            return pFind->pFun();   // 这个括号别再忘了
        }
        pFind = pFind->pNext;
    }
    return NULL;
}

// Product.h

#pragma once
#include <string>
#include "ReflectFactory.h"

class CProduct
{
public:
    CProduct(void);
    virtual ~CProduct(void);
    virtual void DoSomething();
};

class CProductA : public CProduct
{
    DECLARE_REFLECT(CProductA);
相当于
// private:
//     static void* _CreateInstance_()
//     {
//         return new CProductA();
//     };
//     static wchar_t _m_AddFunc_;
//     static wchar_t _AddFunc_()
//     {
//         CReflectFactory::AddInstance("CProductA", &_CreateInstance_);
//         return 0;
//     }
public:
    CProductA();
    void DoSomething();

protected:
private:
};

class CProductB : public CProduct
{
    DECLARE_REFLECT(CProductB);
public:
    CProductB();
    void DoSomething();

protected:
private:
};

// Product.cpp

#include ".\product.h"
#include <iostream>

CProduct::CProduct(void)
{
}

CProduct::~CProduct(void)
{
}

void CProduct::DoSomething()
{

}

IMPLEMENT_REFLECT(CProductA);
相当于
// wchar_t CProductA::_m_AddFunc_ = _AddFunc_();

CProductA::CProductA()
{
    std::cout << "CProductA" << std::endl;
}

void CProductA::DoSomething()
{
    std::cout << "CProductA::DoSomething()" << std::endl;
}

IMPLEMENT_REFLECT(CProductB);
CProductB::CProductB()
{
    std::cout << "CProductB" << std::endl;
}

void CProductB::DoSomething()
{
    std::cout << "CProductB::DoSomething()" << std::endl;
}

// main.cpp

#include "ReflectFactory.h"
#include "Product.h"

int main()
{
    CProduct* p = static_cast<CProduct*>(CReflectFactory::GetInstance("CProductA"));
    if ( NULL != p )
    {
         p->DoSomething();
    }
    CProduct* p1 = static_cast<CProduct*>(CReflectFactory::GetInstance("CProductB"));
    if ( NULL != p1 )
    {
         p1->DoSomething();
    }
    CProduct* p2 = static_cast<CProduct*>(CReflectFactory::GetInstance("CProductC"));
    if ( NULL != p2 )
    {
         p2->DoSomething();
    }
    return 0;
}