MFC之RTTI与动态创建

最新推荐文章于 2024-08-02 10:43:58 发布

weixin_34329187

最新推荐文章于 2024-08-02 10:43:58 发布

阅读量74

点赞数

文章标签：数据结构与算法 c/c++

原文链接：http://www.cnblogs.com/qzhforthelife/p/3142870.html

版权

本人能力、精力有限，所言所感都基于自身的实践和有限的阅读、查阅，如有错误，欢迎拍砖，敬请赐教——博客园：钱智慧。

在说RTTI之前需要明白c++中类静态成员的初始化特点：类的静态数据成员需要在类体外显式初始化（const 类型的静态数据成员才能在类体内直接初始化）。关于数据（全局变量，局部变量，静态变量，类数据成员）的初始化特点可参考《C++primer》相关章节。

还要知道，类的静态成员的初始化发生于main之前，MFC的RTTI机制正是利用了这一特点，从而在进入main函数之前提前把一个信息链表建立起来，而这个链表每个节点便是一个CruntimeClass对象。那么，在main之前就得把链表构建好，这意味着在main之前就得执行代码，试问：什么代码能在main之前得以执行呢？这便是全局对象或者静态对象的构造函数中的代码。比如，有个全局对象Person p;那么，p的造函数会在main执行之前执行，从而我们可以把一些提前完成的任务放在Person的构造函数里，Person本身甚至完全不重要，我们只是想利用它的构造函数来完成自己想要的功能而已，MFC的RTTI也利用了这一点，比如其中的AFX_CLASSINIT类（结构体），它存在的唯一目的就是为了利用其构造函数往链表中添加节点，再比如接下来的模拟例子中的AFX_ClassNode类也是如此。下面的例子仅仅是模拟了RTTI中构建链表的过程，并不是完整的RTTI机制模拟，没有候捷的模拟复杂，所以更容易看懂，代码如下：

 1 #include <iostream>
 2 
 3 //链表节点类
 4 struct ClassNode
 5 {    
 6     ClassNode* next;
 7     //注意，节点类有个静态指针，因为一个链表只需要有一个首指针
 8     static ClassNode* first;//first本身是Node类的静态数据成员，需要在类体外初始化
 9 };
10 ClassNode* ClassNode::first=0;
11 //继承体系
12 /*          Fruit
13             |
14         -----------
15         |         |
16        Orange    Apple
17                   |
18                 BigApple
19 */
20 struct AFX_LISTINIT//这个类的存在只是为了利用其构造函数来给链表增加节点
21 {
22     AFX_LISTINIT(ClassNode* pNode)
23     {
24         printf("添加一个节点构建链表\n");
25         pNode->next=ClassNode::first;
26         ClassNode::first=pNode;
27     }
28 };
29 //Fruit
30 class Fruit
31 {
32 public:
33     static ClassNode node;
34 };
35 //下面两行代码把Fruit的静态数据成员node节点加入链表（此时链表一个节点都没有）
36 ClassNode Fruit::node={0};//Fruit类的指针初始化为0，就是null
37 AFX_LISTINIT initFruit(&Fruit::node);
38 //Orange
39 class Orange:public Fruit
40 {
41 public:
42     static ClassNode node;
43 };
44 ClassNode Orange::node={0};//Node是结构体，所以可以这样初始化
45 AFX_LISTINIT initOrange(&Orange::node);
46 //Apple
47 class Apple:public Fruit
48 {
49 public:
50     static ClassNode node;
51 };
52 ClassNode Apple::node={0};
53 AFX_LISTINIT initApple(&Apple::node);
54 //BigApple
55 class BigApple:public Apple
56 {
57 public:
58     static ClassNode node;
59 };
60 ClassNode BigApple::node={0};
61 AFX_LISTINIT initBigApple(&BigApple::node);
62 
63 int main()
64 {
65     return 0;
66 }

最终可以看到有四句打印语句。

如同MFC中RTTI中的链表一样，本例的链表也是倒着添加节点的，即先添加的节点将会在链表靠后的位置。

引入宏定义：

我们的模拟很简陋，仅仅是模拟出了创建链表的机制，但是这个链表是粗糙的，每个节点几乎没有保存跟特定类相关的信息，比如类名，比如指向基类节点的指针，比如用来创建类实例的函数指针等。而且我们每定义一个新的类，如果想加入链表都需要两句类似的代码：初始化节点，构建一个AFX对象以添加节点，这无疑体力和键盘的消磨，真正的RTTI中用宏避免了手动敲击重复代码，宏并不神秘，代码替换而已。我们一步步完善这个模拟。我们的链表中节点类型是ClassNode，MFC中是CRuntmeClass类型（结构体），而且MFC中每个类的静态数据成员CRuntimeClass对象有不同的名称，格式是：class+类名，比如classOrange，而我们的类中的节点变量名称都叫node，我们就来改进这一点，让每个的节点变量名具备class+类名的格式，利用C语言一种特殊的预处理器语法 a##b得到ab，注意，a和b可以是任意类型的变量名称，通过这种方式可以得到一种新的变量名ab，从而我们的改进方式是：直接将使用node变量名的地方换成class##Fruit，class##Apple，class##Orange……然而这是不行的，因为##语法是预处理器负责的，VC6.0给的错误是：preprocessor command must start as first nonwhite space。这就是在逼着我们用宏定义了，最终改善的代码：

 1 #include <iostream>
 2 
 3 #define DECLARE_DYNAMIC(class_name) \
 4 public: \
 5     static ClassNode class##class_name;
 6 
 7 #define IMPLEMENT_DYNAMIC(class_name) \
 8     ClassNode class_name::class##class_name={0}; \
 9     AFX_LISTINIT init##class_name(&class_name::class##class_name);
10 
11 //链表节点类
12 struct ClassNode
13 {    
14     ClassNode* next;
15     static ClassNode* first;
16 };
17 ClassNode* ClassNode::first=0;
18 
19 struct AFX_LISTINIT
20 {
21     AFX_LISTINIT(ClassNode* pNode)
22     {
23         printf("构建链表:添加一个节点\n");
24         pNode->next=ClassNode::first;
25         ClassNode::first=pNode;
26     }
27 };
28 //Fruit
29 class Fruit
30 {
31 DECLARE_DYNAMIC(Fruit)
32 };
33 IMPLEMENT_DYNAMIC(Fruit);
34 
35 //Orange
36 class Orange:public Fruit
37 {
38 DECLARE_DYNAMIC(Orange)
39 };
40 IMPLEMENT_DYNAMIC(Orange)
41 
42 //Apple
43 class Apple:public Fruit
44 {
45 DECLARE_DYNAMIC(Apple)
46 };
47 IMPLEMENT_DYNAMIC(Apple)
48 //BigApple
49 class BigApple:public Apple
50 {
51 DECLARE_DYNAMIC(BigApple)
52 };
53 IMPLEMENT_DYNAMIC(BigApple)
54 
55 int main()
56 {
57     return 0;
58 }

View Code

引入类名：

 1 #include <iostream>
 2 
 3 //注意宏定义中的#和##语法，前者可把变量名转成字符串
 4 
 5 #define DECLARE_DYNAMIC(class_name) \
 6 public: \
 7     static ClassNode class##class_name;
 8 
 9 #define IMPLEMENT_DYNAMIC(class_name) \
10     char _sz##class_name[]=#class_name; \
11     ClassNode class_name::class##class_name={_sz##class_name,0}; \
12     AFX_LISTINIT init##class_name(&class_name::class##class_name);
13 
14 //链表节点类
15 struct ClassNode
16 {    
17     char* m_szClassName;
18     ClassNode* next;
19     static ClassNode* first;
20 };
21 ClassNode* ClassNode::first=0;
22 
23 struct AFX_LISTINIT
24 {
25     AFX_LISTINIT(ClassNode* pNode)
26     {
27         printf("构建链表:添加一个节点：");
28         printf(pNode->m_szClassName);
29         printf("\n");
30         pNode->next=ClassNode::first;
31         ClassNode::first=pNode;
32     }
33 };
34 //Fruit
35 class Fruit
36 {
37 DECLARE_DYNAMIC(Fruit)
38 };
39 IMPLEMENT_DYNAMIC(Fruit);
40 
41 //Orange
42 class Orange:public Fruit
43 {
44 DECLARE_DYNAMIC(Orange)
45 };
46 IMPLEMENT_DYNAMIC(Orange)
47 
48 //Apple
49 class Apple:public Fruit
50 {
51 DECLARE_DYNAMIC(Apple)
52 };
53 IMPLEMENT_DYNAMIC(Apple)
54 //BigApple
55 class BigApple:public Apple
56 {
57 DECLARE_DYNAMIC(BigApple)
58 };
59 IMPLEMENT_DYNAMIC(BigApple)
60 
61 int main()
62 {
63     return 0;
64 }

View Code

引入继承关系：

引入继承关系，便是在节点类中增加一个指向父类结点的指针，问题是如何初始这个指针呢，这要求我们必须提供获得某个类的节点指针的方法，从而我们需要定义RUNTIME_CLASS宏，它接收类名，返回类的节点指针。还要注意，终极父类Fruit并没有父类，所以不能像其他类那样对其直接使用实现宏，而是要特殊处理，即把其父类置空（毕竟RUNTIME_CLASS宏不能接收NULL），事实上RUNTIME_CLASS宏与即将实现的GetRuntimClass成员函数功能是一样的，只不过一个是宏，一个是成员函数，只能通过类对象调用。最终代码如下：

 1 #include <iostream>
 2 
 3 //注意宏定义中的#和##语法，前者可把变量名转成字符串
 4 #define RUNTIME_CLASS(class_name) (&class_name::class##class_name)
 5 #define DECLARE_DYNAMIC(class_name) \
 6 public: \
 7     static ClassNode class##class_name; \
 8     ClassNode* GetRuntimeClass();
 9 
10 #define IMPLEMENT_DYNAMIC(class_name,base_class_name) \
11     char _sz##class_name[]=#class_name; \
12     ClassNode class_name::class##class_name={RUNTIME_CLASS(base_class_name),_sz##class_name,0}; \
13     AFX_LISTINIT init##class_name(&class_name::class##class_name); \
14     ClassNode* class_name::GetRuntimeClass(){return &class_name::class##class_name;}
15 
16 //链表节点类
17 struct ClassNode
18 {    
19     ClassNode* m_baseClass;
20     char* m_szClassName;
21     ClassNode* next;
22     static ClassNode* first;
23 };
24 ClassNode* ClassNode::first=0;
25 
26 struct AFX_LISTINIT
27 {
28     AFX_LISTINIT(ClassNode* pNode)
29     {
30         printf("构建链表:添加一个节点：");
31         printf(pNode->m_szClassName);
32         printf("\n");
33         pNode->next=ClassNode::first;
34         ClassNode::first=pNode;
35     }
36 };
37 //Fruit
38 class Fruit
39 {
40 DECLARE_DYNAMIC(Fruit)
41 };
42 //IMPLEMENT_DYNAMIC(Fruit);特殊处理最终父类，MFC中便是上帝CObject
43 char _szFruit[]="Fruit"; 
44 ClassNode Fruit::classFruit={/*RUNTIME_CLASS(base_class_name)*/NULL,_szFruit,0}; 
45 AFX_LISTINIT initFruit(&Fruit::classFruit); 
46 
47 //Orange
48 class Orange:public Fruit
49 {
50 DECLARE_DYNAMIC(Orange)
51 };
52 IMPLEMENT_DYNAMIC(Orange,Fruit)
53 
54 //Apple
55 class Apple:public Fruit
56 {
57 DECLARE_DYNAMIC(Apple)
58 };
59 IMPLEMENT_DYNAMIC(Apple,Fruit)
60 //BigApple
61 class BigApple:public Apple
62 {
63 DECLARE_DYNAMIC(BigApple)
64 };
65 IMPLEMENT_DYNAMIC(BigApple,Apple)
66 
67 int main()
68 {
69     printf("***********************\n");
70     //**测试链表中基类信息
71     //打印出各个类及父类名称
72     for(ClassNode* cursor=ClassNode::first;cursor!=NULL;)
73     {
74         ClassNode * baseClass=cursor->m_baseClass;
75         if(baseClass!=NULL)
76         {
77             printf("%s : %s\n",cursor->m_szClassName,baseClass->m_szClassName);
78         }
79         else
80         {
81             printf(cursor->m_szClassName);
82             printf("\n");
83         }
84         cursor=cursor->next;
85     }
86     printf("***********************\n");
87     //**用GetRumtimeClass方法测试
88     //找出ba所属类型的所有祖宗
89     BigApple ba;
90     for(ClassNode* findBase=ba.GetRuntimeClass()->m_baseClass;findBase!=NULL;)
91     {
92         printf(findBase->m_szClassName);
93         printf("\n");
94         findBase=findBase->m_baseClass;
95     }
96     
97     return 0;
98 }

View Code

引入类型识别函数IsKindOf函数：

把IsKindOf定义在根父类Fruit中，这样后代类都能继承到。IsKindOf是一个普通的成员函数，其参数是一个ClassNode指针（MFC中则是CRuntimeClass指针），它的思想很简单：先用本类的ClassNode指针与参数比较，若不相等再用本类的父类的ClassNode指针去比较……一旦相等，便返回真。比较两指针的值是完全没问题的，我们知道，若两指针的值相等，便能说明二者指向同一个对象，此处若两指针相等则说明二者指向同一个ClassNode对象。

尤其要注意的是：之前我们的GetRuntimeClass对象不是虚函数，但到这一步，它必须得是虚函数，因为IsKindOf调用了GetRuntimeClass函数，看代码：

BigApple ba;

printf("%d\n",ba.isKindOf(RUNTIME_CLASS(Apple)));

若没用虚函数，则执行到isKindOf中时，不能做到动态绑定而调用ba自己的GetRuntimeClass函数，从而出现逻辑错误。完整代码：

 1 #include <iostream>
 2 
 3 //注意宏定义中的#和##语法，前者可把变量名转成字符串
 4 #define RUNTIME_CLASS(class_name) (&class_name::class##class_name)
 5 #define DECLARE_DYNAMIC(class_name) \
 6 public: \
 7     static ClassNode class##class_name; \
 8     virtual ClassNode* GetRuntimeClass();//这里必须是虚函数！！
 9 
10 #define IMPLEMENT_DYNAMIC(class_name,base_class_name) \
11     char _sz##class_name[]=#class_name; \
12     ClassNode class_name::class##class_name={RUNTIME_CLASS(base_class_name),_sz##class_name,0}; \
13     AFX_LISTINIT init##class_name(&class_name::class##class_name); \
14     ClassNode* class_name::GetRuntimeClass(){return &class_name::class##class_name;}
15 
16 //链表节点类
17 struct ClassNode
18 {    
19     ClassNode* m_baseClass;
20     char* m_szClassName;
21     ClassNode* next;
22     static ClassNode* first;
23 };
24 ClassNode* ClassNode::first=0;
25 
26 struct AFX_LISTINIT
27 {
28     AFX_LISTINIT(ClassNode* pNode)
29     {
30         printf("构建链表:添加一个节点：");
31         printf(pNode->m_szClassName);
32         printf("\n");
33         pNode->next=ClassNode::first;
34         ClassNode::first=pNode;
35     }
36 };
37 
38 //Fruit
39 class Fruit
40 {
41 public:
42     bool isKindOf(ClassNode* pNode);
43 DECLARE_DYNAMIC(Fruit)
44 };
45 //IMPLEMENT_DYNAMIC(Fruit);特殊处理最终父类，MFC中便是上帝CObject
46 char _szFruit[]="Fruit"; 
47 ClassNode Fruit::classFruit={/*RUNTIME_CLASS(base_class_name)*/NULL,_szFruit,0}; 
48 AFX_LISTINIT initFruit(&Fruit::classFruit); 
49 ClassNode* Fruit::GetRuntimeClass(){return &Fruit::classFruit;}
50 bool Fruit::isKindOf(ClassNode* pNode)
51 {
52     for(ClassNode* cursor=this->GetRuntimeClass();cursor!=NULL;)
53     {
54         if(cursor==pNode)
55         {
56             return true;
57         }
58         cursor=cursor->m_baseClass;
59     }
60     return false;
61 }
62 
63 //Orange
64 class Orange:public Fruit
65 {
66 DECLARE_DYNAMIC(Orange)
67 };
68 IMPLEMENT_DYNAMIC(Orange,Fruit)
69 
70 //Apple
71 class Apple:public Fruit
72 {
73 DECLARE_DYNAMIC(Apple)
74 };
75 IMPLEMENT_DYNAMIC(Apple,Fruit)
76 //BigApple
77 class BigApple:public Apple
78 {
79 DECLARE_DYNAMIC(BigApple)
80 };
81 IMPLEMENT_DYNAMIC(BigApple,Apple)
82 
83 int main()
84 {
85     BigApple ba;
86     //**测试isKindOf(此处最值得注意的地方便是Fruit类的GetRuntimeClass必须得是虚函数）
87     printf("%d\n",ba.isKindOf(RUNTIME_CLASS(Apple)));
88     printf("%d\n",ba.isKindOf(RUNTIME_CLASS(Orange)));
89     
90     return 0;
91 }

View Code

另外，本示例代码的全局变量不像候捷的示例代码那样让全局变量都为静态的，这并无大碍，但要明白全局的静态变量只能在本文件中使用，虽然其生命周期是整个程序的运行期，非静态的全局变量才能通过extern声明被外部文件使用，全局函数也是这样。

引入动态创建：

思想就是为每个类加入一个静态的createObject函数，为ClassNode节点加入一个函数指针成员，构建链表时中每个节点时，把指针指向每个类自己的createObject函数，从而将来有了相应类的节点指针（即CRuntimClass指针）便能调用相应的createObject方法。需要注意的是，我们也为ClassNode引入一个普通的成员方法CreateObject，这个方法是将来动态创建时真正要调用的方法，它的存在不过是让功能更优雅一些，其实没有它也可以，不过调用者需要自己判断ClassNode对象里的函数指针是不是为空，不为空才能调用该指针指向的类的静态createObject方法。至今，为了省事，我们的根级父类Fruit定义中一直还有动态声明宏，但这里要把它拿掉而用具体的代码了，因为我们不让Fruit具备动态创建功能，即不给其添加createObject方法，其节点中的m_pfnCreateObject指针也置空。另外为了测试方便，我们给根父类Fruit加入了虚方法sayHello，子类都覆写了这个方法，候捷的的动态创建示例代码中有Load方法，其实它完成的便是本例的main函数代码，候哥这么做是为了契合后续的持久化机制。完整代码：

  1 #include <iostream>
  2 
  3 //注意宏定义中的#和##语法，前者可把变量名转成字符串
  4 #define RUNTIME_CLASS(class_name) (&class_name::class##class_name)
  5 #define DECLARE_DYNAMIC(class_name) \
  6 public: \
  7     static ClassNode class##class_name; \
  8     virtual ClassNode* GetRuntimeClass(); \
  9     static Fruit* createObject();
 10 
 11 #define IMPLEMENT_DYNAMIC(class_name,base_class_name) \
 12     char _sz##class_name[]=#class_name; \
 13     ClassNode class_name::class##class_name={class_name::createObject,\
 14                     RUNTIME_CLASS(base_class_name),_sz##class_name,0}; \
 15     AFX_LISTINIT init##class_name(&class_name::class##class_name); \
 16     ClassNode* class_name::GetRuntimeClass(){return &class_name::class##class_name;} \
 17     Fruit* class_name::createObject() {return new class_name;}
 18 
 19 
 20 //**链表节点类
 21 //提前用到了Fruit类，需要前向声明
 22 class Fruit;
 23 struct ClassNode
 24 {    
 25     Fruit* CreateObject();
 26     Fruit* (*m_pfnCreateObject)();
 27     ClassNode* m_baseClass;
 28     char* m_szClassName;
 29     ClassNode* next;
 30     static ClassNode* first;
 31 };
 32 Fruit* ClassNode::CreateObject()
 33 {
 34     if(m_pfnCreateObject==NULL)
 35     {
 36         printf("这个类不支持动态创建\n");
 37         return NULL;
 38     }
 39     return m_pfnCreateObject();
 40 }
 41 ClassNode* ClassNode::first=0;
 42 
 43 struct AFX_LISTINIT
 44 {
 45     AFX_LISTINIT(ClassNode* pNode)
 46     {
 47         printf("构建链表:添加一个节点：");
 48         printf(pNode->m_szClassName);
 49         printf("\n");
 50         pNode->next=ClassNode::first;
 51         ClassNode::first=pNode;
 52     }
 53 };
 54 
 55 //Fruit
 56 class Fruit
 57 {
 58 public:
 59     virtual void sayHello(){printf("hello Fruit\n");}
 60     bool isKindOf(ClassNode* pNode);
 61     static ClassNode classFruit; 
 62     virtual ClassNode* GetRuntimeClass(); 
 63 };
 64 //IMPLEMENT_DYNAMIC(Fruit);特殊处理最终父类，MFC中便是上帝CObject
 65 char _szFruit[]="Fruit"; 
 66 ClassNode Fruit::classFruit={NULL,/*RUNTIME_CLASS(base_class_name)*/NULL,_szFruit,0}; 
 67 AFX_LISTINIT initFruit(&Fruit::classFruit); 
 68 ClassNode* Fruit::GetRuntimeClass(){return &Fruit::classFruit;}
 69 bool Fruit::isKindOf(ClassNode* pNode)
 70 {
 71     for(ClassNode* cursor=this->GetRuntimeClass();cursor!=NULL;)
 72     {
 73         if(cursor==pNode)
 74         {
 75             return true;
 76         }
 77         cursor=cursor->m_baseClass;
 78     }
 79     return false;
 80 }
 81 
 82 //Orange
 83 class Orange:public Fruit
 84 {
 85 public:
 86     void sayHello(){printf("hello Orange\n");}
 87 DECLARE_DYNAMIC(Orange)
 88 };
 89 IMPLEMENT_DYNAMIC(Orange,Fruit)
 90 
 91 //Apple
 92 class Apple:public Fruit
 93 {
 94 public:
 95     void sayHello(){printf("hello Apple\n");}
 96 DECLARE_DYNAMIC(Apple)
 97 };
 98 IMPLEMENT_DYNAMIC(Apple,Fruit)
 99 //BigApple
100 class BigApple:public Apple
101 {
102 public:
103     void sayHello(){printf("hello BigApple\n");}
104 DECLARE_DYNAMIC(BigApple)
105 };
106 IMPLEMENT_DYNAMIC(BigApple,Apple)
107 
108 int main()
109 {
110     //**动态创建测试
111     char className[128];
112     scanf("%s",&className);
113     for(ClassNode* cursor=ClassNode::first;cursor!=NULL;)
114     {
115         if(strcmp(cursor->m_szClassName,className)==0)
116         {
117             cursor->CreateObject()->sayHello();
118             break;
119         }
120         cursor=cursor->next;
121     }
122     return 0;
123 }

View Code

到此，本示例算是完全结束了，为了简单省事，本示例对候哥的例子做了尽可能的简化。

转载于:https://www.cnblogs.com/qzhforthelife/p/3142870.html

weixin_34329187

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MFC之RTTI与动态创建

本人能力、精力有限，所言所感都基于自身的实践和有限的阅读、查阅，如有错误，欢迎拍砖，敬请赐教——博客园：钱智慧。在说RTTI之前需要明白c++中类静态成员的初始化特点：类的静态数据成员需要在类体外显式初始化（const 类型的静态数据成员才能在类体内直接初始化）。关于数据（全局变量，局部变量，静态变量，类数据成员）的初始化特点可参考《C++primer》相关章节。还要知道，类的静态成员的初...
复制链接

扫一扫