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;
}