阅读114 返回首页    go 阿里云 go 技术社区[云栖]


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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  1. struct AA  
  2. {  
  3.     int a;  
  4.     char b;  
  5. }xxy;  
结构体可以嵌套,因而可以把一个结构体当成另一个结构体的成员,例:

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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. }  


最后更新:2017-08-13 22:41:10

  上一篇:go  为什么网站seo优化要持续进行不能暂停?
  下一篇:go  东芝开发高速对照大数据技术 比传统处理技术快50倍