学习笔记之深入浅出MFC 第9章 仿真MFC之二
RTTI（执行期类型识别）
在前面章节中我们介绍过Visual C++4.0支持RTTI，重点不外乎是：
1、编译时需选用/GR（/GR的意思是enable C++ RTTI）
2、包含typeinfo.h
3、使用新的typeid运算符。
其实，MFC在编译器支持RTTI之前，就有了这项能力。我们现在要以相同的手法，在Console程序中仿真出来。我希望我的类库具备IsKindOf的能力，能在执行期侦测某个对象是否“属于某种类”，并传回TRUE或FALSE。以前一章的Shape为例，我希望：
CSquare* pSquare = new CSquare;
cout << pSquare->IsKindOf(CSquare); //应该获得1（TRUE）
cout << pSquare->IsKindOf(CRect); //应该获得1（TRUE）
cout << pSquare->IsKindOf(CShape); //应该获得1（TRUE）
cout << pSquare->IsKindOf(CCircle); //应该获得0（FALSE）
以MFC的类层次来说，我希望：
CMyDoc* pMyDoc = new CMyDoc;
cout << pMyDoc->IsKindOf(CMyDoc); //应该获得1（TRUE）
cout << pMyDoc->IsKindOf(CDocument); //应该获得1（TRUE）
cout << pMyDoc->IsKindOf(CCmdTarget); //应该获得1（TRUE）
cout << pMyDoc->IsKindOf(CWnd); //应该获得0（FALSE）
类别型录网与CRuntimeClass
怎么设计RTTI呢？让我们想想，当你看到一种颜色，想知道它的RGB成分比，不查色表行吗？当你持有一种产品，想知道它的型号，不查型录行吗？同样的道理，要达到RTTI的能力，类库的设计者一定要在建构起来的时候，记录必要的信息，以建立型录。型录中的类信息，最好以链表方式链接起来，将来方便一一比较。
我们这份“类别型录”的链表元素将以CRuntimeClass描述，这是一个结构，其中至少需要类名称、链表的Next指针，以及链表的First指针。由于First指针属于全局变量，所以它应该以static修饰之。除此之外，你所看到的其它CRuntimeClass成员都是为了其他目的而准备的，陆陆续续我会介绍。
//in MFC.H
struct CRuntimeClass
{
//属性
LPCSTR m_lpszClassName;
int m_nObjectSize;
UINT m_wSchema;
CObject* (PASCAL* m_pfnCreateObject)();
CRuntimeClass* m_pBaseClass;
//CRuntimeClass对象再简单的列表中链接在一起
static CRuntimeClass* pFirstClass; //类列表的开始
CRuntimeClass* m_pNextClass; //链表中登记的类
}；
为了能够查找每一个构建的类的类型信息，我们希望每一个类都能拥有一个这样的CRuntimeClass成员变量，并且最好有一定的命名规则，然后，经由某种手段将整个类库建构好之后，“类别型录”能呈现类似这样的风貌：
总结一下上面想要讲的内容：我们希望查询每一个类的类型信息，那么就得有一个包含所有类型信息这样的一个表，每次将类信息与表中信息挨个比对，就能获得想要查的类的类型信息了。那么我们就需要先建立这样一个表。这个表就像上面图中所示的样子。表中的每一项都是一个包含许多条信息的结构。
DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC宏
既然目的是为了创建一个这样的链表，那么第一步就是在每个类中首先建立CRuntimeClass对象，并且声明一个可以抓到该对象地址的函数，我们定义DECLARE_DYNAMIC宏如下：
#define DECLARE_DYNAMIC(class_name) \
public: \
static CRuntimeClass class##class_name
virtual CRuntimeClass* GetRuntimeClass() const;
出现在宏定义中的##，用来告诉编译器，把两个字符串系在一起。如果这么使用宏：
DECLARE_DYNAMIC(CView)
编译器前置处理器实际做出的代码是：
public:
static CRuntimeClass classCView
virtual CRuntimeClass* GetRuntimeClass() const;
这下子，只要在声明类时放入DECLARE_DYNAMIC宏就可以了。
当然，具体每一个CRuntimeClass对象的内容还没有单独指定，以及链接工作也没有做，于是我们再定义IMPLEMENT_DYNAMIC宏：
#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
_IMPLEMENT_RUNTIMECLASS(class_name,base_class_name, 0xFFFF, NULL)
其中，_IMPLEMENT_RUNTIMECLASS又是一个宏。
#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; } \
其中，RUNTIME_CLASS宏定义如下：
#define RUNTIME_CLASS(class_name) \
(&class_name::class##class_name)
看起来整个IMPLEMENT_DYNAMIC内容好像只是指定初值，其实不然，其美妙处在于它所使用的一个struct AFX_CLASSINIT,定义如下：
struct AFX_CLASSINIT
{ AFX_CLASS(CRuntimeClass* pNewClass) ; };
这表示它有一个构造函数（struct和class都有构造函数），定义如下：
AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass* pNewClass)
{
pNewClass->m_pNextClass = CRuntimeClass :: pFirstClass;
CRuntimeClass :: pFirstClass = pNewClass;
}
很显然，此构造函数负责linked list的链接工作。
于是乎，程序中只需要简简单单的两个宏DECLARE_DYNAMIC(Cxxx)和IMPLEMENT_DYNAMIC(Cxxx, Cxxxbase), 就完成了建构数据并加入链表的工作：
可是，链表的头总是需要特别的费心处理，不能套用一般的链表行为方式。我们的类根源CObject，不能套用现成的宏DECLARE_DYNAMIC和IMPLEMENT_DYNAMIC,必须特别设计如下：
//in header file
class CObject
{
public:
virtual CRuntimeClass* GetRuntimeClass() const;
. . .
public:
static CRuntimeClass classCObject;
};
//in implementation file
static char szCObject[] = "CObject";
struct CRuntimeClass CObject::classCObject =
{ szCObject, sizeof(CObject), 0xffff, NULL, NULL};
static AFX_CLASSINIT _init_CObject(&CObject :: classCObject);
CRuntimeClass* CObject::GetRuntimeClass() const
{
return &CObject :: classCObject;
}
并且，CRuntimeClass中的static成员变量应该要初始化
CRuntimeClass* CRuntimeClass::pFirstClass = NULL;
终于，整个“类别型录”链表的头部就这样形成了：
范例程序Frame3在.h文档中有这类声明：
class CObject
{
. . .
};
class CCmdTarget : public CObject
{
DECLARE_DYNAMIC(CCmdTarget)
. . .
};
class CWinThread : public CCmdTarget
{
DECLARE_DYNAMIC(CWinThread)
. . .
};
class CWinApp : public CWinThread
{
DECLARE_DYNAMIC(CWinApp)
. . .
};
class CDocument : public CCmdTarget
{
DECLARE_DYNAMIC(CDocument)
. . .
};
class CWnd : public CCmdTarget
{
DECLARE_DYNAMIC(CWnd) //其实在MFC中是DECLARE_DYNCREATE()
. . .
};
class CFrameWnd : public CWnd
{
DECLARE_DYNAMIC(CFrameWnd) //其实在MFC中是DECLARE_DYNCREATE()
. . .
};
class CView : public CWnd
{
DECLARE_DYNAMIC(CView)
. . .
};
于是组织出这样一张大网：
IsKindOf(类型识别)
有了上图这种“类别型录”网，要实现IsKindOf功能，就再轻松不过了：
1、为CObject加上一个IsKindOf函数，于是此函数将被所有类继承。它将把参数所指定的某个CRuntimeClass对象拿来与类别型录中的元素一一比较。比较成功（在型录中发现），就传回TRUE，否则传回FALSE:
//in header file
class CObject
{
public:
BOOL IsKindOf(const CRuntimeClass* pClass) const;
};
//in implementation file
BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
{
CRuntimeClass* pClassThis = GetRuntimeClass();
while (pClassThis != NULL)
{
if(pClassThis == pClass)
return TRUE;
pClassThis = pClassThis->m_pBaseClass;
}
return FALSE;
}
注意，while循环中所追踪的是“同宗”路线，也就是凭借着m_pBaseClass而非m_pNextClass。假设我们调用的是：CView* pView = new CView;
pView->IsKindOf(RUNTIME_CLASS(CWinApp));
IsKindOf的参数其实就是&CWinApp::classCWinApp。函数利用GetRuntimeClass先取得&CView::classCView，然后循线而上（所谓的循线而上分别指CView、CWnd、CCmdTarget、CObject），每获得一个CRuntimeClass对象指针，就拿来和CView::classCView的指针比较。靠这个土办法，完成了IsKindOf能力。
2、IsKindOf的使用方法如下：
CMyDoc* pMyDoc = new CMyDoc;
CMyView* pMyView = new CMyView;
cout <<pMyDoc->IsKindOf(RUNTIME_CLASS(CMyDoc)); //应该获得TRUE
cout <<pMyDoc->IsKindOf(RUNTIME_CLASS(CDocument)); //应该获得TRUE
cout <<pMyDoc->IsKindOf(RUNTIME_CLASS(CCmdTarget)); //应该获得TRUE
cout <<pMyDoc->IsKindOf(RUNTIME_CLASS(CObject)); //应该获得TRUE
cout <<pMyDoc->IsKindOf(RUNTIME_CLASS(CWinApp)); //应该获得FALSE
cout <<pMyDoc->IsKindOf(RUNTIME_CLASS(CView)); //应该获得FALSE
cout <<pMyView->IsKindOf(RUNTIME_CLASS(CView)); //应该获得TRUE
cout <<pMyView->IsKindOf(RUNTIME_CLASS(CObject)); //应该获得TRUE
cout <<pMyView->IsKindOf(RUNTIME_CLASS(CWnd)); //应该获得TRUE
cout <<pMyView->IsKindOf(RUNTIME_CLASS(CFrameWnd)); //应该获得FALSE