说说MFC中CRuntimeClass和CObject之间的那点事

MSDN曰：对于MFC中每个从CObject派生的类来说，都有一个相关的CRuntimeClass结构体，在程序运行时可以访问该结构体来获取对象及其基类的信息。

CRuntimeClass是一个结构体，并且其本身并没有基类。

在运行时确定一个对象的类型是很重要的，尤其是在做类型检查时；而c++语言本身并不支持运行时类信息。

CObject和CRuntimeClass是MFC中两个非常重要的类/结构,绝大部分MFC类都是以CObject做为基类， CRuntimeClass结构同CObject密不可分，了解它们对于深入理解MFC具有重要意义。
CRuntimeClass 的定义如下：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

structCRuntimeClass

{

// Attributes

LPCSTRm_lpszClassName;      //类名，一般是指包含CRuntimeClass对象的类的名称

int m_nObjectSize;               //包含CRuntimeClass对象的类sizeof的大小，不包括它分配的内存

UINT m_wSchema;               // schema number of the loaded class

CObject* (PASCAL* m_pfnCreateObject)();// NULL => abstract class 指向一个建立实例的构造函数

#ifdef _AFXDLL

CRuntimeClass* (PASCAL* m_pfnGetBaseClass)();

#else

CRuntimeClass* m_pBaseClass;//m_pBaseClass的指针(函数)是MFC运行时确定类层次的关键，它一个简单的单向链表

#endif

// Operations

//这个函数给予CObject 派生类运行时动态建立的能力

CObject* CreateObject();

//这个函数使用 m_pBaseClass或 m_pfnGetBaseClass遍历整个类层次确定是否pBaseClass指向的类是基类，

//使用它可以判断某类是否是从pBaseClass指向的类在派生来。

BOOLIsDerivedFrom(constCRuntimeClass* pBaseClass) const;

// Implementation

voidStore(CArchive& ar) const;

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

// 单向链表，每个类的CRuntimeClass结构体对象的 m_pNextClass 都指向其直接基类的CRuntimeClass结构体对象

// 这一点可以在IMPLEMENT_RUNTIMECLASS 宏定义中看到

CRuntimeClass* m_pNextClass;// linked list of registered classes

};

二、CObject类
CObject是MFC类的大多数类的基类，主要是通过它实现：
(1)、运行类信息；(2)、序列化；(3)、对象诊断输出；(4)、同集合类相兼容；
(1)、运行时类信息:
注意：要想使用CRuntimeClass结构得到运行时类信息，你必须在你的类中包括DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC、 DECLARE_DYNCREATE/IMPLEMENT_DYNCREATE或DECLARE_SERIAL/IMPLEMENT_SERIAL。但你的类必须是从CObject派生的才能使用这些宏， 因为通过DECLARE_DYNAMIC将定义一个实现如下的函数:
CRuntimeClass* PASCAL B::_GetBaseClass()
{
return RUNTIME_CLASS(base_name);
}

其中的RUNTIME_CLASS是这样定义的

?

1

2

#define RUNTIME_CLASS( class_name ) \

(CRuntimeClass *)(&class_name::class##class_name);

即得到类中的CRuntimeClass对象指针，显而易见，如果没有基类你用IMPLEMENT_DYNAMIC时将得到一个编译错误。 除非你象CObject一样不用DECLARE_DYNAMIC而定义和实现了这些函数，CObject中的GetBaseClass只是简单的返回NULL。 实际的DECLARE_DYNAMIC在afx.h中声明如下：

?

1

2

3

4

5

6

7

8

#define DECLARE_DYNAMIC(classname) \

protected: \

staticCRuntimeClass* PASCAL _GetBaseClass(); \

public: \

// 为使用DECLARE_DYNAMI宏的类声明一个静态CRuntimeClass对象，并且指定其名字为“class” + “class_name”

//##class_name 在预处理阶段会被自动翻译为后面class_name

staticconst AFX_DATA CRuntimeClassclass##class_name; \

virtualCRuntimeClass* GetRuntimeClass() const; \

IMPLEMENT_DYNAMIC在afx.h中定义如下：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

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

CRuntimeClass* PASCAL class_name::_GetBaseClass() \

{ returnRUNTIME_CLASS(base_class_name); } \

// 初始化类class_name的CRuntimeClass静态变量，注意与CRuntimeClass结构体的定义对应观察：

// 其m_pNextClass被赋值为&class_name::_GetBaseClass，而_GetBaseClass的定义如上，其直接返回

// 了基类的CRuntimeClass变量，这与上面对 m_pNextClass的解释吻合。

AFX_COMDAT const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \

#class_name, sizeof(class class_name), wSchema, pfnNew, \

&class_name::_GetBaseClass, NULL }; \

//重写GetRuntimeClass虚函数，这个函数最初的定义在CObject中，重写后，将返回子类自己的GetRuntimeClass变量

CRuntimeClass* class_name::GetRuntimeClass()const \

{ returnRUNTIME_CLASS(class_name); } \

总而言之，DECLARE_DYNAMIC（用于类的定义体中）与 IMPLEMENT_RUNTIMECLASS（用于类的实现文件中）这两个宏，主要就是在预处理阶段自动生成（更准确说应该是宏翻译转换）用于类运行时检查的函数和变量，主要包括获取其基类的CRuntimeClass变量的函数_GetBaseClass，类本身的CRuntimeClass静态变量定义，同时将类本身的CRuntimeClass静态变量与其基类的CRuntimeClass静态变量绑定起来，使得子类的该变量可以直接访问到基类的变量，并且这种绑定是从子类到其基类递归进行的。在运行时判断类信息时，就可以通过类的CRuntimeClass静态变量来进行对比，从而判断出该类是否是相应的类型，这便是CObject中接口函数IsKindOf函数的作用，其实现类似于下面的过程：

?

1

2

3

4

5

6

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

{

     CRuntimeClass *pClassThis = GetRuntimeClass();

     while(pClassThis != NULL)

     {

     // 检查CRuntimeClass静态变量是否相同，若相同，则表示所检查的pClass是对的

?

1

2

3

4

5

6

7

8

      if(pClassThis == pClass)

         {

              return TRUE;

         }

         pClassThis = pClassThis->m_pBaseClass;

     }

     returnFALSE;

}

其中的CRuntimeClass* GetRuntimeClass() const;被定义为虚函数，以完成在类层次上的重载。 这也是MFC利用多态实现运行时动态类信息的方法。
另外两个DECLARE_DYNCREATE和DECLARE_SERIAL类似。只不过它们多定义和实现了一些函数，对于使用DECLARE_DYNCREATE 要注意的是类必须要有一个无参数的缺省构造函数，因为在DECLARE_DYNCREATE中定义了一个CreateObject函数 用以在动态的建立对象，它只是一条简单的return new class_name。
我们先来看一下序列化：
，CObject实现这些功能绝大部分是通过它里面的CRuntimeClass对象classObject实现的,
CObject不支持多重继承，即表示以CObject为基类的类层次中只能有一个CObject基类。

之所以会这样，就是因为CRuntimeClass对象的成员m_pBaseClass的关系。因为它只是一个单链表。
以下是它在afx.h中的定义：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

/////////////////////////////////////////////////////////////////////////////

// class CObject is the root of all compliant objects

#ifdef _AFXDLL

classCObject

#else

classAFX_NOVTABLE CObject

#endif

{

public:

// Object model (types, destruction, allocation)

virtualCRuntimeClass* GetRuntimeClass() const;

// 上面的函数的实现只是很简单的return RUNTIME_CLASS(classObject);

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

// Diagnostic allocations

void* PASCAL operatornew(size_tnSize);

void* PASCAL operatornew(size_t,void* p);

voidPASCAL operator delete(void* p);

#if _MSC_VER >= 1200

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

#endif

#if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT)

// for file name/line number tracking using DEBUG_NEW

void* PASCAL operatornew(size_tnSize, LPCSTRlpszFileName, intnLine);

#if _MSC_VER >= 1200

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

#endif

#endif

// 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(constCObject& objectSrc); // no implementation

voidoperator=(constCObject& objectSrc); // no implementation

// Attributes

public:

BOOLIsSerializable() const;// 对对象进行序列化

BOOLIsKindOf(constCRuntimeClass* pClass) const;//判是否是

// Overridables

virtualvoid Serialize(CArchive& ar);

#if defined(_DEBUG) || defined(_AFXDLL)

// Diagnostic Support

virtualvoid AssertValid() const;

virtualvoid Dump(CDumpContext& dc)const;

#endif

// Implementation

public:

staticconst AFX_DATA CRuntimeClass classCObject;

#ifdef _AFXDLL

staticCRuntimeClass* PASCAL _GetBaseClass();

#endif

};

参考链接：

 

 

 

 

 

 

 

 

DECLARE_DYNAMIC宏与DECLARE_DYNCREATE宏

在1当中看到了DECLARE_DYNAMIC的源码实现，DECLARE_DYNCREATE及对应的IMPLEMENT_DYNCREATE宏源码如下：

?

1

2

3

4

// not serializable, but dynamically constructable

#define DECLARE_DYNCREATE(class_name) \

    DECLARE_DYNAMIC(class_name) \

    staticCObject* PASCAL CreateObject();

?

1

<br>#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \<br> CObject* PASCAL class_name::CreateObject() \<br>  {return new class_name; } \<br> IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \<br>  class_name::CreateObject, NULL)

可见，“DYNCREATE” 不仅包含了“DYNAMIC”，而且多了一样很重要的东西，那就是静态函数CreateObject()。在声明了这样一个函数后，该类就能支持“动态”对象创建，但是前提是类必须有默认的构造函数，这可以从 CreateObject的实现中看出来，它仅仅是创建并返回了一个类对象。

这样，与CRuntimeClass相结合使用，就可以动态的创建对象。这里所谓的动态，我的理解是指不需要用户自己编码去创建，而是由MFC框架去创建。比如在单文档视图中：

?

1

2

3

4

5

6

pDocTemplate = new CSingleDocTemplate(

  IDR_MAINFRAME,

  RUNTIME_CLASS(CMSMoneyDemoDoc),

  RUNTIME_CLASS(CMainFrame),      // main SDI frame window

  RUNTIME_CLASS(CMSMoneyDemoView));

AddDocTemplate(pDocTemplate);

上面的代码中， RUNTIME_CLASS（class_name）便是返回了相应的类的CRuntimeClass静态变量，然后从上一篇中可知，这个CRuntimeClass类型的静态变量中包含了其对应的类的名字，并且其本身实现了一个CreateObject函数，这样，CRuntimeClass静态变量便可以根据其本身的信息来动态创建一个其所属者的对象。这便是为啥MFC框架通过上面类似的文档模板代码自动为我们创建了Mainframe、doc以及view了，因此在MFC 的doc-view结构中，我们并不需要自己去显示创建主窗口、文档和视图，这些都由文档模板类去完成了。文档模板类的主要作用就是将这三者联系起来。

 

 

http://www.cnblogs.com/liqilei/archive/2010/09/18/1830381.html