C语言模式实现C++继承和多态

C语言模式实现C++继承和多态

描述：

C实现一个struct A和struct B各包含一个int成员a和b，要求达到B继承了A的效果，也就是B里面包含一个A。并且能达

到多态的效果，也就是一个A*p指向A调的是A的函数，指向B调用的是B的函数。

C++中的继承、多态

继承是面向对象复用的重要手段。通过继承定义一个类，继承是类型之间的关系建模，共享公有的东西，实现各自本质

不同的东西。 

继承是一种复用手段，在继承关系里基类的成员类的成员派生类的成员，由此达到复用的目的。

 如果你想学习C/C++可以来这个群，首先是三三零，中间是八五九，最后是七六六，里面可以学习和交流，也有学习资料可以可以下载。

所谓多态，其实就是“多种形态”。

C++中虚函数的主要作用就是实现多态。简单说父类的指针/引用调用重写的虚函数，当父类指针/引用指向父类对象

时调用的是父类的虚函数，指向子类对象时调用的是子类的虚函数。

[cpp] view plain copy

1. #include <iostream>  
2. #include <assert.h>  
3. #include <Windows.h>  
4. using namespace std;  
5.   
6. //C++中的多态  
7. class AA  
8. {  
9. public:  
10.     virtual void fun1()  
11.     {  
12.         cout << "AA::fun1()" << endl;  
13.     }  
14.     virtual void fun2()  
15.     {  
16.         cout << "AA::fun2()" << endl;  
17.     }  
18. private:  
19.     int _aa;  
20. };  
21.   
22.   
23. class BB :public AA   //公有继承  
24. {  
25. public:  
26.     virtual void fun1()     //子类重写父类的虚函数时，子类的virtual可以不写  
27.     {  
28.         cout << "BB::fun1()" << endl;  
29.     }  
30.     virtual void fun2()  
31.     {  
32.         cout << "BB::fun2()" << endl;  
33.     }  
34. private:  
35.     int _bb;  
36. };  

[cpp] view plain copy

1. #include "源.h"  
2.   
3. void Test()  
4. {  
5.     AA tty;  
6.     BB vvz;  
7.     AA* p = &tty;   //父类指针指向父类引用  
8.     p->fun1();      //父类指针指向父类对象  
9.     p->fun2();  
10.     p = &vvz;      //父类指针指向子类引用，多态体现  
11.     p->fun1();     //父类指针指向子类对象  
12.     p->fun2();  
13. }  
14.   
15. int main()  
16. {  
17.     Test();  
18.     system("pause");  
19.     return 0;  
20. }  

而用C语言又怎样实现C++的继承和多态呢？

C语言是一种面向过程的程序设计语言，而C++是在C语言基础上衍生来的面向对象的语言，实际上，很多C++实现的底层是用C语言实现的。

C++在语言级别添加了很多新的机制（封装、继承、多态...）。而在C语言中，我们也可以使用这样的机制，前提是我们需要自己实现。

基本思想：

1.结构体

在C语言中，我们常常把一个对象用结构体进行封装，这样便于对对象进行操作，例：

[cpp] view plain copy

1. struct AA  
2. {  
3.     int a;  
4.     char b;  
5. }xxy;  

结构体可以嵌套，因而可以把一个结构体当成另一个结构体的成员，例：

[cpp] view plain copy

1. struct AA  
2. {  
3.     int a;  
4.     char b;  
5. }xxy;  
6.   
7. struct BB  
8. {  
9.     int c;  
10.     double q;  
11.     struct AA tty;  
12. }zzo;  

2.函数指针

顾名思义，函数指针就是指向函数的指针，它是一个指针，指向函数的首地址，函数名即为该函数的首地址。

[cpp] view plain copy

1. //Fun函数为一个返回值为char* 的函数  
2. char* Fun(char* p1, char* p2)  
3. {  
4.     int i = 0;  
5.     i = strcmp(p1, p2);  
6.     if (i == 0)  
7.     {  
8.         return p1;  
9.     }  
10.     else  
11.     {  
12.         return p2;  
13.     }  
14. }  
15.   
16. int main()  
17. {  
18.     char* (*tty)(char* p1, char* p2);   //tty为一个函数指针  
19.     tty = &Fun;  
20.     (*tty)("aa", "bb");  
21.     system("pause");  
22.     return 0;  
23. }  

C语言实现继承、多态

在C语言中，可以利用“结构在内存中的布局与结构的声明具有一致的顺序”这一事实实现继承。

[cpp] view plain copy

1. //用一个函数指针  
2. typedef void(*FUN)();            
3.   
4. //父类  
5. struct AA  
6. {  
7.     FUN fun;  
8. };  
9.   
10. //子类  
11. struct BB  
12. {  
13.     AA a;  
14. };  
15.   
16. void FunA()  
17. {  
18.     printf("AA::fun\n");  
19. }  
20.   
21. void FunB()  
22. {  
23.     printf("BB::fun\n");  
24. }  

[cpp] view plain copy

1. void Test()  
2. {  
3.     AA a;  
4.     BB b;  
5.     a.fun = FunA;   //父类对象调用父类函数  
6.     b.a.fun = FunB;   //子类对象调用子类函数  
7.   
8.     AA* p = &a;   //定义一个父类指针指向父类对象  
9.     p->fun();    //调用父类的fun函数  
10.     p = (AA*)&b;   //父类指针指向子类对象  
11.     p->fun();    //调用子类的fun函数  
12. }  
13.   
14. int main()  
15. {  
16.     Test();  
17.     system("pause");  
18.     return 0;  
19. }