动态类型识别&动态创建

以下大部分内容摘自《windows程序设计 第2版》 王艳平 张铮 编著

动态类型识别：在程序运行过程中，辨别对象是否属于特定类的技术。

应用举例：函数辨别参数类型、需要针对对象的类编写特定的代码。

CRuntimeClass 包含类信息(不仅包含一般的信息，还包括创建类的函数指针)

#include <iostream>
#include<windows.h>
using namespace std;
/////////////////////////////////////////////////////
// 运行期类信息
class CObject;
struct CRuntimeClass
{
// 属性（Attributes）
LPCSTR m_lpszClassName;        // 类的名称
int m_nObjectSize;             // 类的大小
UINT m_wSchema;                // 类的版本号
// 创建类的函数的指针 函数返回值为CObject*类型 调用规则为__stdcall
// 如果你没有显式的说明调用规则的话，编译器会统一按照_cdecl来处理
// c++ 指针：http://hipercomer.blog.51cto.com/4415661/792300
CObject* (__stdcall* m_pfnCreateObject)();
CRuntimeClass* m_pBaseClass;   // 其基类中CRuntimeClass结构的地址

// 操作（operations）
CObject* CreateObject();       //调用m_pfnCreateObject指向的函数
BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

// 内部实现（Implementation）
CRuntimeClass* m_pNextClass;  // 将所有CRuntimeClass对象用简单链表连在一起
};

如果想使所有的类都具有运行期识别和动态创建的特性，那么必须有一个类做为最顶层的类，所有的类都从此类继承。

// CObject 类
class CObject
{
public:
//注意是个虚函数
virtual CRuntimeClass* GetRuntimeClass() const;
virtual ~CObject();

// 属性（Attibutes）
public:
BOOL IsKindOf(const CRuntimeClass* pClass) const;

// 实现（implementation）
public:
static const CRuntimeClass classCObject; //   标识类的静态成员
};

上面是两个类的声明，下面我们看实现：

//CRuntimeClass类实现
inline CObject::~CObject() { }

// 宏定义
// RUNTIME_CLASS宏用来取得class_name类中CRuntimeClass结构的地址
#define RUNTIME_CLASS(class_name) ((CRuntimeClass*)&class_name::class##class_name)

CObject* CRuntimeClass::CreateObject()
{
if(m_pfnCreateObject == NULL)
return NULL;
return (*m_pfnCreateObject)(); // 调用创建类的函数
}

BOOL CRuntimeClass::IsDerivedFrom(const CRuntimeClass* pBaseClass) const
{
//this指针:  http://blog.csdn.net/ugg/article/details/606396 //this指针作为一个隐含参数传递给非静态成员函数，用以指向该成员函数所属类所定义的对象。
const CRuntimeClass* pClassThis = this;
while(pClassThis != NULL)
{
if(pClassThis == pBaseClass) // 判断标识类的CRuntimeClass的首地址是否相同
return TRUE;
pClassThis = pClassThis->m_pBaseClass;
}
return FALSE; // 查找到了继承结构的顶层，没有一个匹配
}

const struct CRuntimeClass CObject::classCObject =
{ "CObject"/*类名*/, sizeof(CObject)/*大小*/, 0xffff/*无版本号*/,
NULL/*不支持动态创建*/, NULL/*没有基类*/, NULL};

CRuntimeClass* CObject::GetRuntimeClass() const
{
// 下面的语句展开后就是“return ((CRuntimeClass*)&(CObject::classCObject));”
return RUNTIME_CLASS(CObject);
}
//CObject类的实现
BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
{
CRuntimeClass* pClassThis = GetRuntimeClass();
return pClassThis->IsDerivedFrom(pClass);
}

动态类型识别举例：

class CPerson : public CObject
{
public:
virtual CRuntimeClass* GetRuntimeClass() const
{ return (CRuntimeClass*)&classCPerson; }

static const CRuntimeClass classCPerson;
};
const CRuntimeClass CPerson::classCPerson =
{ "CPerson", sizeof(CPerson), 0xffff, NULL, (CRuntimeClass*)&CObject::classCObject, NULL };
//   类名        大小      版本号  创建类的函数的指针  基类中CRuntimeClass结构的地址
void main()
{
// 父类指向子类，只能调用两者都有的函数（虚函数）
// 如果父类想调用子类拥有，父类没有的函数是不可以的
// 也就是父类指向子类只能调用子类的虚函数
CObject* pMyObject = new CPerson;

// 判断对象pMyObject是否属于CPerson类或者此类的派生类
if(pMyObject->IsKindOf(RUNTIME_CLASS(CPerson)))
// RUNTIME_CLASS(CPerson)宏被展开后相当于((CRuntimeClass*)&CPerson::classCPerson)
{
CPerson* pMyPerson = (CPerson*)pMyObject;
cout << "a CPerson Object! \n";

// 返回类的信息，要从CRuntimeClass中提取
CRuntimeClass* pClass = pMyObject->GetRuntimeClass();
cout << pClass->m_lpszClassName << "\n";   // 打印出"CPerson"
cout << pClass->m_nObjectSize << "\n";       // 打印出"4" x64为"8"
delete pMyPerson;
}
else
{
delete pMyObject;
}

}

动态创建举例：

//声明
class CPerson : public CObject
{
public:
virtual CRuntimeClass* GetRuntimeClass() const
{ return (CRuntimeClass*)&classCPerson; }

static const CRuntimeClass classCPerson;

static CObject* __stdcall CreateObject()
{ return new CPerson; }
};
//实现
const CRuntimeClass CPerson::classCPerson =
{ "CPerson", sizeof(CPerson), 0xffff, &CPerson::CreateObject/*添加到这里*/, (CRuntimeClass*)&CObject::classCObject, NULL };
//   类名            大小                 版本号      创建类的函数的指针                             基类中CRuntimeClass结构的地址
void main()
{
// 取得CPerson类中CRuntimeClass结构记录的信息
// 在实际应用中，我们一般从磁盘上取得这一信息，
// 从而在代码中没有给出类名的情况下创建该类的对象
CRuntimeClass* pRuntimeClass = RUNTIME_CLASS(CPerson);

// 取得了pRuntimeClass指针，不用知道类的名字就可以创建该类
CObject* pObject = pRuntimeClass->CreateObject();
if(pObject != NULL && pObject->IsKindOf(RUNTIME_CLASS(CPerson)))
{
cout << "创建成功！\n";
delete pObject;
}
}

MFC对它们进行“优化”，使用了看起来很恶心的宏：

//以下都采用了多行宏定义
// 支持动态类型识别的宏
//声明
#define DECLARE_DYNAMIC(class_name) \
public: \
static const CRuntimeClass class##class_name; \
virtual CRuntimeClass* GetRuntimeClass() const;
//实现
#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
const CRuntimeClass class_name::class##class_name = { \
#class_name, sizeof(class class_name), wSchema, pfnNew, \
RUNTIME_CLASS(base_class_name), NULL }; \
CRuntimeClass* class_name::GetRuntimeClass() const \
{ return RUNTIME_CLASS(class_name); } \
//运行期识别功能只需要类名与基类名即可
#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)

// 支持动态创建的宏
//声明
#define DECLARE_DYNCREATE(class_name) \
DECLARE_DYNAMIC(class_name) \
static CObject* __stdcall CreateObject();
//实现
#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
CObject* __stdcall class_name::CreateObject() \
{ return new class_name; } \
IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
class_name::CreateObject)

动态创建的等价代码：

// 等价代码：

class CPerson : public CObject
{
DECLARE_DYNCREATE(CPerson)  　　　　//声明
};
IMPLEMENT_DYNCREATE(CPerson, CObject)  //实现

void main() // main函数里的代码没有变化
{
CRuntimeClass* pRuntimeClass = RUNTIME_CLASS(CPerson);
CObject* pObject = pRuntimeClass->CreateObject();
if(pObject != NULL && pObject->IsKindOf(RUNTIME_CLASS(CPerson)))
{
cout << " 创建成功！\n";
delete pObject;
}
}