关于OOP中若干特性的思考

Rainyboy

       由于最近在学习Python，了解了很多所谓Python的新特性，无非是更加方便和精确地实现了面对对象（OOP）编程的精髓。有些网友甚至急匆匆地就拿Python与各种语言作比较了，我想说的是，并非C++不能这样做，是因为它不必这样做（关于C++的四种编程层面，请参考《Effective C++》，面对对象编程，只是其中的一种）。

       要想用C++实现这些现代面对对象编程语言的典范功能，并不需要改进语法，只需要精妙地构建一些类和宏就可以了，关于这项工作的典范，是微软出品的MFC（Microsoft Fundation Class）系列库类，设计这些库类的出发点，是将面对对象的观点引入基于windows的应用程序设计上，其亮点在于这是一个完全构建在C++之上的库类，并没有修改C++语法，实现了WINDOWS下面对对象编程所谓的“六大关键技术”，分别是：
      类层级结构（对应于Python的“万物皆对象”思想，所有的MFC类都有共同的基类：CObject类）；
      运行时类型识别（对应于Python的type()函数，接受任何东西作为参数，返回的字符串告诉你这个东西是什么类别）；
      动态创建（相当于Python的cPickle库或者Pickle库的load()函数，从文件中还原类的实例）；
      永久保存（相当于Python的cPickle库或者Pickle库的dump()函数，将类的实例保存到文件）；
      消息映射（操作系统相关的技术）；
      命令传递（操作系统相关的技术）；

       当年在研习候俊杰的《深入浅出MFC》时，照着书上的讲解构建了一个可以实现“动态创建”和“运行时类型识别”以及“永久保存”的“类层级结构”。再贴代码之前，让我再说说这四个名词的意思吧，实际上，我认为，他们只是一个问题的四个方面：
       因为我们要实现最纯粹的面对对象编程，即按照“万物皆对象”的观点，能操作的所有东西都应该是某个类的对象，而类与类之间的关系，应该组织在一张大“网”中，什么类的子类是什么，万物的源头是什么类，等等。库类框架中各类的关系，构成了类层级结构。
       既然万物皆对象，我们有理由要求像保存数据一样将我们操作的对象保存在磁盘上，这就是永久保存技术，而且在需要的时候从磁盘读入内存并再现这个对象，这就是动态创建技术；这两个技术要求我们必须做到，在一个类被创建出来后，还能获知他是什么类的对象，这就是运行时类型识别技术；
       让我们来想想运行时类型识别：
       例如，在Human类->Man类->Child类这样的框架中，要执行一个全局的FindAWomanToMarry（Human *p），就要先确定当前的p是什么？当然，我们知道它是Human类，子类和父类总是有Is-A关系，即Chinld类的对象是一个 Human类对象（ Child IS A Human）。但是我们无法知道p表示的是Human的那个子类的对象，当然我们有其它办法例如获取年龄值等等来避开这个特定的问题，但是并没有回答我们为了说明的那个问题：怎么在一个类的对象被创建出来之后还能得到这个对象在类层级结构中的位置？）

    说了这么多，总而言之，我认为，运行时类型识别、动态创建、永久保存和类层级结构是面对对象语言（或框架）所必须提供的特性。MFC框架和《深入浅出MFC》告诉我们，如何在C++中构造出这出这些特性。
   
    多年前的依样画葫芦的一些代码，帖出来给大家看看吧。
    RTCT.h ：包含非常精妙的宏定义，是实现运行时类型识别的关键

1. 
   
2. #ifndef RTTCTRT
   
3. #define RTTCTRT
   
4. #define FIRST_CLASS Human
   
5. #define RTTI_PRE(X)  \
   
6.      static RUNTIMECLASS X##class;\
   
7.      virtual RUNTIMECLASS* GetRunTimeClass() const;
   
8. #define RTTI_LINK(new_class,basic_class)\
   
9. static char new_class##_p[]=#new_class;\
   
10. RUNTIMECLASS new_class::new_class##class={\
    
11.         new_class##_p,sizeof(new_class),&basic_class::basic_class##class,NULL,NULL};\
    
12. static RFX_init init##new_class(&new_class::new_class##class);\
    
13. RUNTIMECLASS* new_class::GetRunTimeClass() const\
    
14. {return &new_class::new_class##class;}\
    
15. #define RTCT_PRE(X) \
    
16.     static RUNTIMECLASS X##class;\
    
17.     virtual RUNTIMECLASS* GetRunTimeClass() const;\
    
18.     static Human* RUNTIMECREAT();
    
19. #define RTCT_LINK(new_class,basic_class)\
    
20. Human *new_class::RUNTIMECREAT()\
    
21. {return new new_class; }\
    
22. static char new_class##_p[]=#new_class;\
    
23. RUNTIMECLASS new_class::new_class##class={\
    
24. new_class##_p,sizeof(new_class),&basic_class::basic_class##class,new_class::RUNTIMECREAT,NULL};\
    
25. static RFX_init init##new_class(&new_class::new_class##class);\
    
26. RUNTIMECLASS* new_class::GetRunTimeClass() const\
    
27. {return &new_class::new_class##class;}
    
28. /////////////////////////////////////////////////
    
29.     class FIRST_CLASS;
    
30. /*在引用之前，这是非常必要的*/
    
31. struct RUNTIMECLASS
    
32. {
    
33. char * name;
    
34. int size;
    
35. RUNTIMECLASS *basic;//指向父类
    
36.     FIRST_CLASS* (*pf_Creat)();
    
37.     FIRST_CLASS* RTCreat();
    
38. RUNTIMECLASS *next;//指向下一节点
    
39. static  RUNTIMECLASS *First;
    
40. };
    
41. /////////////////////////////////////////////////
    
42. class RFX_init
    
43. {
    
44. public:
    
45. RFX_init(RUNTIMECLASS *newclass);
    
46. };
    
47. #endif
    

复制代码

    UDF.h：自己构建的几个类，形成一个以Human类为源头的小框架

1. #ifndef UDFF
   
2. #define UDFF
   
3. #define R_DEBUG
   
4. #include "RTCT.h"
   
5. int CMP(char s1[],char s2[]);
   
6. class Human
   
7. {
   
8. public:
   
9. Human(int a=1,int i=1);
   
10. inline int Getage(){return age;};
    
11. inline int GetID(){return age;};
    
12. RTTI_PRE(Human)
    
13. private:
    
14. int age;
    
15. int ID;
    
16. };
    
17. ////////////////////////////
    
18. class Man:public Human
    
19. {
    
20. public:
    
21. Man(int a=1,int i=1,int ifm=1);
    
22. RTCT_PRE(Man)
    
23. inline int GetMarryStatue(){return ifmarry;};
    
24. private:
    
25. int ifmarry;
    
26. };
    
27. ///////////////////////////
    
28. class Woman:public Human
    
29. {
    
30. public:
    
31. Woman(int a=1,int i=1,int ifm=1);
    
32. RTCT_PRE(Woman)
    
33. inline int GetMarryStatue(){return ifmarry;};
    
34. private:
    
35. int ifmarry;
    
36. };
    
37. //////////////////////////////////
    
38. class Child:public Human
    
39. {
    
40. public:
    
41. Child(int a=1,int i=1,int g=1);
    
42. RTTI_PRE(Child)
    
43. inline int GetGrade(){return grade;};
    
44. private:
    
45. int grade;
    
46. };
    
47. //////////////////////////////////
    
48. class Baby:public Child
    
49. {
    
50. public:
    
51. Baby(int a=1,int i=1,int g=1,int iq=1);
    
52. RTTI_PRE(Baby)
    
53. inline int GetIQ(){return IQ;};
    
54. private:
    
55. int IQ;
    
56. };
    
57. #endif

复制代码

    UDF.cpp：自己构建的几个类，形成一个以Human类为源头的小框架

1. 
   
2. #include "UDF.h"
   
3. #include <iostream.h>
   
4. #include <string.h>
   
5. RFX_init::RFX_init(RUNTIMECLASS *newclass)
   
6. {
   
7. #ifdef R_DEBUG
   
8. if(RUNTIMECLASS::First!=NULL)
   
9. {cout<<"First_pre"<<"["<<RUNTIMECLASS::First->name<<"]"<<endl;}
   
10. else{cout<<"First_pre"<<"NULL"<<endl;}
    
11.     #endif
    
12. ///////////////初始化链表///////////
    
13. newclass->next =RUNTIMECLASS::First;
    
14.     RUNTIMECLASS::First=newclass;
    
15. /////////////////////////
    
16.     #ifdef R_DEBUG
    
17. cout<<"["<<newclass->name<<"]"<<"LINKED"<<endl;
    
18. cout<<"First_"<<"["<<RUNTIMECLASS::First->name<<"]"<<endl;
    
19. cout<<"*****************************"<<endl<<endl;
    
20.     #endif
    
21. }
    
22. RUNTIMECLASS* RUNTIMECLASS::First =NULL;
    
23. static char Human_p[]="Human";
    
24. RUNTIMECLASS Human::Humanclass={Human_p,sizeof(Human),NULL,NULL,NULL};
    
25. RFX_init initHuman(&Human::Humanclass);
    
26. RUNTIMECLASS* Human::GetRunTimeClass() const
    
27. {return &Human::Humanclass;}
    
28. Human::Human(int a,int i)
    
29. {
    
30. cout<<"Human Creat."<<endl;
    
31. age=a;
    
32. ID=i;
    
33. }
    
34. Man::Man(int a,int i,int ifm):Human(a,i)
    
35. {
    
36. cout<<"Man Creat."<<endl;
    
37. ifmarry=ifm;
    
38. }
    
39. Woman::Woman(int a,int i,int ifm):Human(a,i)
    
40. {
    
41. cout<<"Woman Creat."<<endl;
    
42. ifmarry=ifm;
    
43. }
    
44. Child::Child(int a,int i,int g):Human(a,i)
    
45. {
    
46. cout<<"Child Creat."<<endl;
    
47. grade=g;
    
48. }
    
49. Baby::Baby(int a,int i,int g,int iq):Child(a,i,g)
    
50. {
    
51. cout<<"Baby Creat."<<endl;
    
52. IQ=iq;
    
53. }
    
54. Human* RUNTIMECLASS::RTCreat()
    
55. {
    
56. if(pf_Creat==NULL)
    
57. {
    
58.   cout<<"此子类不支持动态创建。"<<endl;
    
59.   return NULL;
    
60. }
    
61. else
    
62. {
    
63.   return (*pf_Creat)();
    
64. }
    
65. }
    
66. int CMP(char s1[],char s2[])
    
67. {
    
68. int i=0;
    
69. if (strlen(s1)!=strlen(s2))
    
70.      return 0;
    
71. for(;s1[i]!='\0';i++)
    
72. {
    
73.   if(s1[i]!=s2[i])
    
74.    return 0;
    
75. }
    
76. return 1;
    
77. }
    
78. RTTI_LINK(Baby,Child)
    
79. RTCT_LINK(Man,Human)
    
80. RTCT_LINK(Woman,Human)
    
81. RTTI_LINK(Child,Human)

复制代码

    main.cpp：通过往这个框架中添加一个类来说明如何使用这些特性

1. 
   
2. #include <iostream.h>
   
3. #include <stdlib.h>
   
4. #include "UDF.h"
   
5. 
   
6. class Rainyboy:public Baby
   
7. {
   
8. public:
   
9. Rainyboy(int a=1,int i=1,int g=1,int iq=1);
   
10. ~Rainyboy();
    
11. RTCT_PRE(Rainyboy)
    
12. };
    
13. Rainyboy::Rainyboy(int a,int i,int g,int iq):Baby(a,i,g,iq)
    
14. {
    
15. cout<<"Rainyboy Creat."<<endl;
    
16. }
    
17. Rainyboy::~Rainyboy(){cout<<"Rainyboy Broken";};
    
18.     RTCT_LINK(Rainyboy,Baby)
    
19. int main()
    
20. {
    
21. RUNTIMECLASS *pnow;
    
22. RUNTIMECLASS *pbas;
    
23. Human *newp;
    
24. char s[10];
    
25. cout<<"**********"<<endl<<"类别目录表"<<endl<<"**********"<<endl;
    
26. for(pnow=RUNTIMECLASS::First;pnow!=NULL;pnow=pnow->next)
    
27. {
    
28.   cout<<pnow->name<<"["<<pnow->size<<"]";
    
29.   for(pbas=pnow->basic;pbas!=NULL;pbas=pbas->basic)
    
30.    cout<<"<-"<<pbas->name<<"["<<pbas->size<<"]";
    
31.         cout<<endl;
    
32. }
    
33. cout<<"***********************************"<<endl;
    
34. cout<<"动态创建测试，输入要创建的类名:";
    
35. cin>>s;
    
36. cout<<"***********************************"<<endl;
    
37. for(pnow=RUNTIMECLASS::First;pnow!=NULL;pnow=pnow->next)
    
38. {
    
39.   if(CMP(pnow->name,s))
    
40.   {
    
41.    cout<<"Class "<<pnow->name<<"  FOUNED!"<<endl;
    
42.    newp=pnow->RTCreat();
    
43.    break;
    
44.   }
    
45. }
    
46. if(pnow==NULL)
    
47.   cout<<"Class "<<s<<" NOT FOUNED!"<<endl;
    
48. delete newp;
    
49. return 1;
    
50. }

复制代码

      程序运行之后，显示出这些信息：
      
      输入要创建的类名后，显示：
      
      说明动态创建成功。

      PS:花了些时间写了这个有点长的东西，是因为随着学习Python的推进，觉得很多东西都是似曾相识，是已有技术的另一种实现。因此翻出这些老古董代码，整理自己的思路，就当是抛砖引玉吧，呵呵！

      PS2:《深入浅出MFC》是一本不可多得的好书，今日再读，更觉得它是求知路上不可多得的良师益友，全书四篇：“勿在浮沙筑高台”，“欲善工事先利其器”，“浅出MFC程序设计”，“深入MFC程序设计”，不急不躁，带领读者慢慢品味代码之美，编程之乐，令人流连忘返！

firecat_2

思路清晰 有自己的见解 前途无量

smtmobly

我喜欢python的原因在于它的方便，简洁，内存处理简单，是跨平台的。
你推荐，mfc什么的好像是Microsoft function collection ，微软的东西用了很多年了，现在我

smtmobly

还是建议 楼主 向linux靠拢，原因很简单，一、开源。二、linux结构的紧凑，软件间无缝连接与共享，运行 速度。win7只开一个ie就消 耗了800+M的内存，linux下只有200+M。

Rainyboy

回复 4 # smtmobly 的帖子

是的，这不遵循兄台的建议学习嘛，有点感想就回来分享了，呵呵。

smtmobly

呵呵！坚持哈！我回复的时候居然弹出说我有非法信息！郁闷，删了很长一段，才发出这几句

Seventy721

侯的那本《深入浅出》(1998年出版) 里面的精华部分基本雷同于《MFC internals: inside the Microsoft Foundation class architecture》(George Shepherd, Scot Wingo, published by Addison-Wesley, 1996)，但是他添了一些例子和花边。两本书我都有，都认真读过，我本科的毕业论文写的就是OOP编程方面的内容。《Effective C++》和《More Effective C++》都是非常好的书。我曾经想做一个C++程序员，但是后来逐渐觉得没意思。计算机语言不过是实现思想的工具，计算机程序只是客观世界的反映，关键的问题是那个思想是什么，客观世界的规律是什么。因此我去读了个PhD。现在我觉得很愉快。

Rainyboy

回复 7 # Seventy721 的帖子

呵呵，我也差不多吧，论坛上的wqsong,fircat_2和我大概和你都有相似的经历吧，现在你是PHD，wqsong现在研究流体，fircat_2在搞故障诊断，这大概就是大家用来建立在变成这套手艺上的“思想”和对“规律”的探索吧。

Seventy721

回复 8 # Rainyboy 的帖子

下次我回北京一定要找你聊聊。