MFC中的RTTI(Runtime Type Identification, 运行时类型识别)详解(参考《深入浅出MFC》)

标签：

  在MFC中的RTTI的实现，主要是利用一个名为CRuntimeClass的结构来链接各个“有关系的类”的信息来实现的。简单来说，就是在需要用到RTTI技术的类内建立CRuntimeClass的静态变量，来储存该类的相关信息(包括类名、基类的CRuntimeClass结构的指针、让“有关系的类”的信息形成链表的next指针、以及链表的首指针(静态)等信息)，这里的“有关系”指的是从同一个基类继承下来的所有的类之间的关系。这些信息(CRuntimeClass)节点的链接过程，简化如下：

(注意: 某个类 (如,CObject) 的CRuntimeClass的变量名就是class接上其类名称 (如：classCObejct) )

  1.建立使用 RTTI 技术的基类时，新建信息链表。

                                        

                                                                                    图1

新建一个需要用到RTTI技术的基类的时候，需要我们创建一个类似图1的CRuntimeClass结构，实际上是初始化了管理所有和该类“有关系”的类的信息的链表，其中，CRuntimeClass的静态变量pFirstClass就是指向该信息链表的首节点的。

  2.建立子类时，将子类信息(子类的CRuntimeClass结构)关联到信息链表。（CCmdTarget 继承自 CObject）

                                                           图2

  将子类的信息也加入到链表中，这时候pFirstClass指针将会指向新的信息。模拟代码如下，

CCmdTarget::classCCmdTarget.next = CRuntimeClass::pFirstClass;
CRuntimeClass::pFirstClass = pCCmdTarget::classCCmdTarget;

  3.后面新建子类的情况类似，直接上图。

    a) CWinThread继承自CCmdTarget，将其信息节点（classCWinThread）加入链表中。

                                                                        图3

      b)  CWnd继承自CCmdTarget,将其信息节点（CWnd::classCWnd）加入信息链表中。

                                                                    图4

  正是由于存在有这样的链表将“有关系的类”的信息（CRuntimeClass结构）关联起来，因此，我们能够很轻松地实现RTTI的相关功能。

  首先，我们来看看每一个信息节点是怎么定义的。

  前面提到了，MFC中每一个使用RTTI的类都会创建一个CRuntimeClass的对象来储存对象的信息，“有点关系的类”之间通过这个结构形成的链表关联起来。在侯捷(侯俊杰)先生的《深入浅出MFC（第二版）》中是这样仿真该结构（CRuntimeClass）的。

struct CRuntimeClass
{
      LPCSTR m_lpszClassName; //包含该CRuntimeClass对象的类的名称。
      int m_nObjectSize; //m_lpszClassName占用的字节数
      UINT m_wSchema;  //分类编号
      CObject* (PASCAL* m_pfnCreateObject)(); //NULL => abstract class,存包含该结构对象的类的构造函数的指针
      CRuntimeClass* m_pBaseClass; //包含该结构对象的类的基类的CRuntimeClass对象指针
       
      //下面是构成链表所需要的变量
      static CRuntimeClass* pFirstClass; //链表的首节点
      CRuntimeClass* m_pNextClass; //该节点的下一个节点。
}

  我们知道，在MFC中要用到RTTI时，总是会使用DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC宏，正是这一对宏，链接“有关系的类”的链表。既然说是“一对”，当然是要成对使用的了，一个用于声明，一个用于定义，你挑柴来我织布，夫妻双双把家还。 = =！

  在具体讨论源代码前，先要知道，宏定义中用#把宏参数变为一个字符串，用##把两个宏参数贴合在一起。 

如，

#include <iostream>
using namespace std;
#define TEST(X) #X
int main()
{
	cout << TEST(TEST) << endl;
}

                               图5

再如，

#include <iostream>

using namespace std;
#define TEST(X, Y)  X##Y
int main()
{
	cout << TEST("X#", "#Y") << endl;
}

输出：

                                图6

  好了，有了上面一系列的讨论，现在我们来专专心心分析一下MFC中的RTTI究竟是怎么实现滴。 +_-!

  首先是声明，声明的宏DECLARE_DYNAMIC的定义如下：

#define  DECLARE_DYNAMIC(class_name) public: 	static CRuntimeClass class##classname; 	virtual CRuntimeClass* GetRuntimeClass() const;

  前面提到，要用到RTTI必须要创建一个静态的CRuntimeClass结构对象，从这个声明的宏，我们可以知道，定义了一个名为class+类名的CRuntimeClass对象，以及回去该对象地址的虚函数。之所以为虚函数，是因为子类和父类返回的CRuntimeClass不一样。

  其次就是实现的宏IMPLEMENT_DYNAMIC，这个宏稍微有一点乱，烦请认真地阅读，实在看不懂的话，也没关系，代码后面我有详细地解读。嘿嘿……闲话少说，上代码。

#define  IMPLEMENT_DYNAMIC(class_name, base_class_name)	_IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)

#define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew)	static char _lpsz##class_name[] = #class_name; 	CRuntimeClass class_name::class##class_name = {	_lpsz##class_name, sizeof(class_name), wSchema, pfnNew, 	RUNTIME_CLASS(base_class_name), NULL }; 	static AFX_CLASSINIT _init_##class_name(&class_name::class##class_name);	CRuntimeClass* class_name::GetRuntimeClass() const         { return &class_name::class##class_name; }
#define RUNTIME_CLASS(class_name)  (&class_name::class##class_name)

 前两行代码，相当于偷梁换柱，这个没什么说的，看得懂宏定义的，都懂！

_IMPLEMENT_RUNTIMECLASS宏，实际上是完成了对DECLARE_DYNAMIC宏声明的CRuntimeClass变量class##class_name的初始化，以及对GetRuntimeClass()函数的定义。下面是截取的部分代码。

static char _lpsz##class_name[] = #class_name;      //获取包含该CRuntimeClass的类的名称
	CRuntimeClass class_name::class##class_name = {\    //初始化CRuntimeClass的参数
	_lpsz##class_name, sizeof(class_name), wSchema, pfnNew, \  
	RUNTIME_CLASS(base_class_name), NULL }; \  

struct AFX_CLASSINIT
{
	AFX_CLASSINIT(CRuntimeClass* pNewClass)
	{
		pNewClass->m_pNextClass = CRuntimeClass::pFirstClass;
		CRuntimeClass::pFirstClass = pNewClass;
	}
};

  在头文件中，我们用DECLARE_DYNAMIC进行声明。

// In *.h file.
class CWnd : public CCmdTarget
{
public:
	CWnd(){}
	~CWnd(){}

	DECLARE_DYNAMIC(CWnd)
/* 上面的DECLARE_DYNAMIC(CWnd)，展开就成为：
public:
	static CRuntimeClass classCWnd; //声明静态变量
	virtual CRuntimeClass* GetRuntimeClass() const;
*/
};

// In *.cpp file
IMPLEMENT_DYNAMIC(Cwnd, CCmdTarget)
/*IMPLEMENT_DYNAMIC(Cwnd, CCmdTarget)，展开就成为：
static char _lpszCWnd[] = "CWnd";
//定义并初始化静态变量classCWnd
CRuntimeClass classCWnd = { _lpszCWnd, sizeof(CWnd), 0xFFFF, NULL,
	                        &CCmdTarget::classCCmdTarget, NULL }
//定义并初始化静态变量_init_CWnd，实际上是在调用其构造函数，将classCWnd连接到链表。
static AFX_CLASSINIT _init_CWnd(&CWnd::classCWnd);
//获得CRuntimeClass对象classCWnd的指针
CRuntimeClass* CWnd::GetRuntimeClass() const
{
	return &CWnd::classCWnd;
}
*/

【参考文献】

  1.侯捷著《深入浅出MFC（第二版）》

  2. MSDN相关内容

MFC中的RTTI(Runtime Type Identification, 运行时类型识别)详解(参考《深入浅出MFC》)

标签：

原文地址：http://blog.csdn.net/yanglingwell/article/details/52003069