MFC程序框架分析 rtti

　　在MFC的设计者们设计MFC的时候，C++规范中并没有包含RTTI，但是他们很早就意识到这个问题，所以他们以一种独特的方式在MFC中实现RTTI，采用这种方式实现的RTTI对于某个对象而言并不是必须的，也就是说，MFC的设计者们并不将RTTI强加于用户所设计的类型上，而是让用户根据自己的需要选择是否他所设计的类型需要RTTI。因而这种方式比C++规范中内置的RTTI更灵活。

　　MFC的设计者们在MFC中采用下面的的方法来实现RTTI：

　　设计一个基类CObject，在CObject中增加RTTI功能，任何一个类型，如果需要具有RTTI功能，就必须直接或间接派生于CObject采用宏实现RTTI，对于某个直接或间接从CObject派生来的类型而言，该宏可有可无，如果有该宏，它就具有RTTI功能，反之则无。

<一>考察CObject

　　我们先从CObject开始，下面是它的定义：

　　class AFX_NOVTABLE CObject

　　{

　　　public:

　　　　// Object model (types, destruction, allocation)

　　　　virtual CRuntimeClass* GetRuntimeClass() const;

　　　　virtual ~CObject(); // virtual destructors are necessary

　　　　// Diagnostic allocations

　　　　void* PASCAL operator new(size_t nSize);

　　　　void* PASCAL operator new(size_t, void* p);

　　　　void PASCAL operator delete(void* p);

　　　　void PASCAL operator delete(void* p, void* pPlace);

　　　　void PASCAL operator delete(void *p, LPCSTR lpszFileName, int nLine);

　　　　// Disable the copy constructor and assignment by default so you will get

　　　　// compiler errors instead of unexpected behaviour if you pass objects

　　　　// by value or assign objects.

　　　protected:

　　　　CObject();

　　　private:

　　　　CObject(const CObject& objectSrc); // no implementation

　　　void operator=(const CObject& objectSrc); // no implementation

　　　// Attributes

　　　public:

　　　　BOOL IsSerializable() const;

　　　　BOOL IsKindOf(const CRuntimeClass* pClass) const;

　　　　// Overridables

　　　　virtual void Serialize(CArchive& ar);

　　　　// Implementation

　　　public:

　　　　static const AFX_DATA CRuntimeClass classCObject;

　　};

总的来说，CObject定义了整个从其派生的家族的所有成员所具有的两个基本的能力：

　　运行时的动态类型检查(RTTI)能力和序列化能力。在早期的C++版本中，没有规定RTTI，但MFC的作者们早就未扑先知，以这种构架的形式定义并实现RTTI。体现RTTI的是CObject中的两个成员函数：

　　virtual CRuntimeClass * GetRuntimeClass() const;

　　BOOL IsKindOf(const CRuntimeClass *pClass) const;

其中，前一个函数用来访问存储RTTI信息的一个CRuntimeClass类型的结构，后一个函数供在运行时刻进行类型判断。我们先来看看CRuntimeClass结构的定义,看看它究竟保存了哪些类型信息。

　　<>

　　struct CRuntimeClass

　　{

　　// Attributes

　　LPCSTR m_lpszClassName;

　　int m_nObjectSize;

　　UINT m_wSchema; // schema number of the loaded class

　　CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class

　　CRuntimeClass* m_pBaseClass;

　　// Operations

　　CObject* CreateObject();

　　BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

　　// Implementation

　　void Store(CArchive& ar) const;

　　static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);

　　// CRuntimeClass objects linked together in simple list

　　CRuntimeClass* m_pNextClass; // linked list of registered classes

　　};

上面就是CRuntimeClass的定义，m_lpszClassName保存类的名称，m_nObjectSize保存类的实例数据所占内存的的大小。我们重点要关注的是m_pBaseClass成员，它是指向名称为m_lpszClassName的类的基类的CRuntimeClass的指针，因此，CRuntimeClass就形成了一个继承链表，这个链表记录了某一族类的继承关系。

　RTTI的实现：

　　实现RTTI的除了上面两个函数外，还有几个相关的宏。我们先看看GetRuntimeClass()和IsKindOf()的实现.

　　1．GetRuntimeClass()的实现

　　CRuntimeClass* CObject::GetRuntimeClass() const

　　{

　　　return RUNTIME_CLASS(CObject);

　　}

　　关键就在RUNTIME_CLASS这个宏上，RUNTIME_CLASS宏的实现如下：

　　#define RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))将宏展开，上面的实现就变成：

　　CRuntimeClass* CObject::GetRuntimeClass() const

　　{

　　　return (CRuntimeClass*)(&CObject::classCObject);

　　}

也就是说，它返回CObject类的一个static型的成员classCObject。

　　2．IsKindOf()的实现

　　BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const

　　{

　　　ASSERT(this != NULL);

　　　// it better be in valid memory, at least for CObject size

　　　ASSERT(AfxIsValidAddress(this, sizeof(CObject)));

　　　// simple SI case

　　　CRuntimeClass* pClassThis = GetRuntimeClass();

　　　return pClassThis->IsDerivedFrom(pClass);

　　　}

前两行我们不管它，关键在于最后一行pClassThis->IsDerivedFrom(pClass),归根结底就是调用CRuntimeClass的IsDerivedFrom()方法。下面是CRuntimeClass的成员IsDerivedFrom()的实现：

　　BOOL CRuntimeClass::IsDerivedFrom(const CRuntimeClass* pBaseClass) const

　　{

　　　ASSERT(this != NULL);

　　　ASSERT(AfxIsValidAddress(this, sizeof(CRuntimeClass), FALSE));

　　　ASSERT(pBaseClass != NULL);

　　　ASSERT(AfxIsValidAddress(pBaseClass, sizeof(CRuntimeClass), FALSE));

　　　// simple SI case

　　　const CRuntimeClass* pClassThis = this;

　　　while (pClassThis != NULL)

　　{

　　　if (pClassThis == pBaseClass) return TRUE;

　　　pClassThis = pClassThis->m_pBaseClass;

　　}

　　　return FALSE; // walked to the top, no match

　　}

　　关键是上面的一段循环代码：

　　while (pClassThis != NULL)

　　{

　　　if (pClassThis == pBaseClass) return TRUE;

　　　pClassThis = pClassThis->m_pBaseClass;

　　　}

它从继承链表的某一节点this开始，向后搜索比较，确定继承关系。

将到这里，或许有人要问，这些CRuntimeClass结构是如何产生的呢？这是一个很好的问题，解决了这个问题，就完全清楚了MFC中RTTI的实现。使用过Visual C++开发程序的人都应该记得DECLARE_DYNAMIC和IMPLEMENT_DYNAMIC这两个宏，它们分别用来定义相应类的static CRuntimeClass成员和对该成员初始化。

　　DECLARE_DYNAMIC宏的定义：

　　#define DECLARE_DYNAMIC(class_name) \

　　public: \

　　static const AFX_DATA CRuntimeClass class##class_name; \

　　virtual CRuntimeClass* GetRuntimeClass() const; \

　　例如DECLARE_DYNAMIC(CView)展开成为：

　　public:

　　　static const AFX_DATA CRuntimeClass classCView;

　　　virtual CRuntimeClass* GetRuntimeClass() const;

由此可见，DECLARE_DYNAMIC宏用来在类的定义中定义静态CRuntimeClass变量和虚拟GetRuntimeClass()函数。可以推断，IMPLEMENT_DYNAMIC宏一定是用来初始化该静态变量和实现GetRuntimeClass()函数，。不错，正是这样！

　　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) \

　　AFX_COMDAT const AFX_DATADEF 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); } \

例如IMPLEMENT_DYNAMIC（CView, CWnd）展开如下：

　　//下面展开的代码用来初始化静态CRuntimeClass变量

　　AFX_COMDATA const AFX_DATADEF CRuntimeClass CView::classCView =

　　{

　　　“CView”, file://m_lpszClassName

　　　sizeof(class CView), file://m_nObjectSize

　　　0xffff, //m_wSchema

　　　NULL, //m_pfnCreateObject

　　　(CRuntimeClass*)(&CWnd::classCWnd), file://m_pBaseClass

　　　NULL //m_pNextClass

　　　}

　　　//下面的代码用来实现GetRuntimeClass()函数

　　　CRuntimeClass* CView::GetRuntimeClass() const

　　　{ return (CRuntimeClass*)(&CView::classCView);}

总的来说，同RTTI有关的宏有下面几对：

　　DECLARE_DYNAMIC和IMPLEMENT_DYNAMIC

这一对宏能够提供运行是类型判断能力。（定义并实现IsKindOf()）

　　DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE

这一对宏除了能够提供类型判断能力外，还能够提供动态创建对象的能力．(定义并实现IsKindOf()和CreateObject()）

　　DECLARE_SERIAL和IMPLEMENT_SERIAL

这一对宏除了提供类型判断能力、动态创建对象能力外，还具有序列化功能。（定义并实现IsKindOf()、CreateObject()和Serialize()）

他的思想就是遍历链表。无论是动态创建，还是动态识别，都需要遍历链表。一定的基础结构能完成一定的应用，从他的成员就看出来了(msdn):

struct   CRuntimeClass
{
LPCSTR   m_lpszClassName;
int   m_nObjectSize;
UINT   m_wSchema
CObject*   (PASCAL*   m_pfnCreateObject)(   );
CRuntimeClass*   (PASCAL*   m_pfnGetBaseClass)(   );
CRuntimeClass*   m_pBaseClass;
CObject*   CreateObject(   );
BOOL   IsDerivedFrom(const   CRuntimeClass*   pBaseClass)   const;
};

他的效率在某些应用中比较低。如果这样的话，尽量避免遍历的出现，可以用一些状态变量完成某些工作。总之要从设计上的应用和结构来考虑。

DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC的宏定义
#   define   DECLARE_DYNAMIC(class_name)\             斜杠表示连接作用
public:
        static   CRuntimeClass   class##class_name;\     //这里就是class##CChildFrame的连接
        virtual   CRuntimeClass   *GetRuntimeClasss()   const;//*号

#define   _IMPLEMENT_RUNTIMECLASS(class_name,   base_class_name,   wSchema,   pfnNew) 
 AFX_DATADEF   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);   }  
class##class_name   他也是个结构。

MFC中RuntiemClass支持的实现：

只要是从CObject派生的类，可以轻松实现RuntiemClass支持。当然，是通过编译器提供的宏来实现的。那么其实现机制是怎样的呢？我觉得只需要四个步骤。

首先让我们简化一下CRuntiemClass和CObject的定义，抽取出与RuntiemClass相关的部分：

struct CRuntimeClass{

char m_lpszClassName[255];

int m_nObjectSize;

CObject* (*m_pfnCreateObject)();

CObject* CreateObject();

};

class CObject{

public:

virtual CRuntimeClass* GetRuntimeClass() const {return NULL;}

static CRuntimeClass classCObject;

virtual ~CObject(){};protected:CObject(){printf("CObject constructed\n");}

};

我所说的四个步骤是（下面的操作都是对于从CObject派生的类而言的）：

1.添加CRuntiemClass类型的静态成员classCMyClass(请把CMyClass换成你的类名）

static CRuntimeClass classCMyClass;

2.覆盖父类（即CObject)的GetRuntimeClass()方法，使之返回classCMyClass的指针

3.添加并实现 CreateObject();方法。

声明：static CObject* CreateObject();

实现：CObject* CMyClass::CreateObject() { return new CMyClass; }

4.为classCMyClass赋值。使m_lpszClassName="CMyClass";

m_nObjectSize=sizeof (CMyClass);

函数指针m_pfnCreateObject指向CMyClass::CreateObject。

CRuntimeClass CMyClass::classCMyClass= {"CMyClass"，sizeof (CMyClass)，CMyClass::CreateObject};

附上完整的例程（摘自Programming Visual C++6.0 Unleashed)：

#include "stdio.h"

#define RUNTIME_CLASS(class_name) (class_name::class##class_name)

class CObject;

struct CRuntimeClass{

char m_lpszClassName[21];

int m_nObjectSize;

CObject* (*m_pfnCreateObject)();

CObject* CreateObject();

};

class CObject{

public:

virtual CRuntimeClass* GetRuntimeClass() const {return NULL;}

static CRuntimeClass classCObject;

virtual ~CObject(){};

protected:

CObject(){printf("CObject constructed\n");}

};

CRuntimeClass CObject::classCObject={"CObject"，sizeof(CObject)，NULL};

CObject* CRuntimeClass::CreateObject()

{

return (*m_pfnCreateObject)();

}

class CAlpha:public CObject{

public:

virtual CRuntimeClass* GetRuntimeClass() const{return classCAlpha;}

static CRuntimeClass classCAlpha;

static CObject* CreateObject();

protected:CAlpha(){printf("CAlpha constructor\n");}

};

CRuntimeClass CAlpha::classCAlpha={"CAlpha"，sizeof(CAlpha)，CAlpha::CreateObject};

CObject* CAlpha::CreateObject(){return new CAlpha;}

///
test()
{

CRuntimeClass* pRTCAlpha=RUNTIME_CLASS(CAlpha);

CObject* pObj1=pRTCAlpha->CreateObject();

}