c++的多态

转自:http://blog.csdn.net/user_define_race/article/details/46277213?locationNum=2&fps=1

[cpp]  view plain  copy
  1. #include <iostream>  
  2. using namespace std;  
  3. //赋值兼容性原则(把子类对象赋给父类指针或引用)  
  4. //函数重写   
  5. //这就是面向对象的新需求  
  6. //如果传来子类对象,那么执行子类函数  
  7. //多态  c++ 编译器提供的多态方案是虚函数  
  8. class Parent  
  9. {  
  10. public:  
  11.     Parent(int a=0)  
  12.     {  
  13.         this->a=a;  
  14.     }  
  15.     virtual void print()  
  16.     {  
  17.        cout<<"a"<<a<<endl;  
  18.     }  
  19. private :  
  20.     int a;  
  21. };  
  22. class Child: public Parent  
  23. {  
  24. public:  
  25.     Child(int b=0)  
  26.     {  
  27.       this->b=b;  
  28.   
  29.     }  
  30.     void print()  
  31.     {  
  32.        cout<<"b"<<b<<endl;  
  33.     }  
  34. private:  
  35.     int b;  
  36. };  
  37. //c++ 是默认是静态编译语言,根据类型,去执行响应的函数 Parent  
  38. //言外之意;:c++ 根据指针类型,去决定到具体的类里面,执行相应操作  
  39. //如果基类中加上virtual 关键字 c++ 编译器会动手脚==》动态链接编译  
  40. //c++ 编译器会来一个迟绑定   
  41. void howtoPrint(Parent *base)  
  42. {  
  43.     base->print();  
  44. }  
  45.   
  46. void howtoPrint2(Parent & base)  
  47. {  
  48.     base.print();  
  49. }  
  50. void main()  
  51. {  
  52.     Parent p1;  
  53.     Child c1;  
  54.     /*p1.print(); 
  55.     c1.print();*/  
  56.       
  57.     Parent * base=NULL;  
  58.     base=&p1;  
  59.     base->print();//打印父类的  
  60.   
  61.     base=&c1;  
  62.     base->print();//打印父类的  
  63.     //p2 是c1 的别名,是c1本身  
  64.     Parent & p2=c1;  
  65.     p2.print();//打印父类的  
  66.     howtoPrint(&p1);  
  67.     howtoPrint(&c1);  
  68.   
  69.     howtoPrint2(p1);  
  70.     howtoPrint2(c1);  
  71.     //以上打印父类的  
  72.     system("pause");  
  73. }  
[cpp]  view plain  copy
  1. </pre><pre name="code" class="cpp">  



多态实例:

[cpp]  view plain  copy
  1. #include <iostream>  
  2. using namespace std;  
  3. class HeroFighter  
  4. {  
  5. public:  
  6.     virtual int Atack()  
  7.     {  
  8.        return 10;  
  9.     }  
  10. protected:  
  11. private:  
  12. };  
  13. class EmenyFighter  
  14. {  
  15. public :  
  16.     int DesoryPower()  
  17.     {  
  18.         return 15;  
  19.     }  
  20. };  
  21. class HeroAd2Fighter:public HeroFighter  
  22. {  
  23. public:  
  24.      int Atack()  
  25.     {  
  26.        return 20;  
  27.     }  
  28. protected:  
  29. private:  
  30. };  
  31.   
  32. void ObjFighter(HeroFighter * pbase,EmenyFighter * emeny )  
  33. {  
  34.     if(pbase->Atack()>emeny->DesoryPower())  
  35.     {  
  36.         printf("主角win\n");  
  37.     }else{  
  38.         printf("主角挂了\n");  
  39.     }  
  40. }  
  41. void main2()  
  42. {  
  43.     HeroFighter h1;  
  44.     EmenyFighter e1;  
  45.     HeroAd2Fighter hadv;  
  46.     if(h1.Atack()>e1.DesoryPower())  
  47.     {  
  48.         printf("主角win\n");  
  49.     }else{  
  50.         printf("主角挂了\n");  
  51.     }  
  52.   
  53.     if(hadv.Atack()>e1.DesoryPower())  
  54.     {  
  55.         printf("主角win\n");  
  56.     }else{  
  57.         printf("主角挂了\n");  
  58.     }  
  59.     system("pause");  
  60. };  
  61. void main()  
  62. {  
  63.     HeroFighter h1;  
  64.     EmenyFighter e1;  
  65.     HeroAd2Fighter hadv;  
  66.     ObjFighter(&h1,&e1);  
  67.     ObjFighter(&hadv,&e1);  
  68. };  


virtual 实现多态,c++ 编译器应该动什么手脚。

第一个需要动手脚的地方  起码这个函数print 我应该动什么手脚

我怎么知道是父类对象还是子类对象?

区分是父类对象还是子类对象0


 当类中声明虚函数时,编译器会在类中生成一个虚函数表。

虚函数表是一个存储类成员函数指针的数据结构

虚函数表是由编译器放入虚函数表中

存入虚函数时,每个对象中都有一个指向虚函数表的指针(vptr 指针)








[cpp]  view plain  copy
  1. #include "iostream"  
  2.   
  3. using namespace std;  
  4.   
  5. class AA  
  6. {  
  7. public:  
  8.     AA(int a= 0)  
  9.     {  
  10.         this->a = a;  
  11.         print(); //在构造函数里面能实现多态吗?  
  12.     }  
  13.   
  14.     //分析一下要想实现多态,c++编译器应该动什么手脚  
  15.     //第一个需要动手脚的地方  起码这个函数print 我应该特殊处理  
  16.     virtual void print()  
  17.     {  
  18.         cout<<"父类的"<<"a"<<a<<endl;  
  19.     }  
  20. protected:  
  21.     int a ;  
  22. };  
  23.   
  24. class BB : public AA  
  25. {  
  26. public:  
  27.     BB(int a= 0, int b = 0)  
  28.     {  
  29.         this->a = a;  
  30.         this->b = b;  
  31.       
  32.     }  
  33.     virtual void print()  
  34.     {  
  35.         cout<<"子类的"<<"a"<<a<<"b"<<b<<endl;  
  36.     }  
  37. private:  
  38.     int b ;  
  39. };  
  40.   
  41.   
  42. void howToPrintf(AA *pBase)  
  43. {  
  44.     //pBase 我怎么知道是父类对象还是子类对象  
  45.     //动手脚2::区分是父类对象还是子类对象,提前布局  
  46.     pBase->print();  //  
  47. }  
  48. void main()  
  49. {  
  50.     //AA a1;  
  51.     BB b1;  
  52.     //howToPrintf(&a1);  
  53.     howToPrintf(&b1);  
  54.     system("pause");  
  55. }  



[cpp]  view plain  copy
  1. #include "iostream"  
  2. using namespace std;  
  3.   
  4. //指针也是一种数据类型,指针数据的数据类型是指,它所指的内存空间的数据类型  
  5. //最后一点引申 指针的步长 。。。c++  
  6.   
  7. class Parent01  
  8. {  
  9. protected:  
  10.     int i;  
  11.     int     j;  
  12. public:  
  13.     virtual void f()  
  14.     {  
  15.         cout<<"Parent01::f"<<endl;  
  16.     }  
  17. };  
  18.   
  19.   
  20. class Child01 : public Parent01  
  21. {     
  22. public:  
  23.     int k;  
  24. public:  
  25.     Child01(int i, int j)  
  26.     {  
  27.         printf("Child01:...do\n");  
  28.     }  
  29.   
  30.     virtual void f()  
  31.     {  
  32.         printf("Child01::f()...do\n");  
  33.     }  
  34. };  
  35.   
  36. void howToF(Parent01 *pBase)  
  37. {  
  38.     pBase->f();  
  39. }  
  40.   
  41. //指针的步长 在c++领域仍然有效,父类指针的步长和子类指针的步长不一样  
  42. //多态是靠迟绑定实现的(vptr+函数指针实现)  
  43. int main06()  
  44. {  
  45.     int i = 0;  
  46.     Parent01* p = NULL;  
  47.     Child01* c = NULL;  
  48.   
  49.     //不要把父类对象还有子类对象同事放在一个数组里面  
  50.     Child01 ca[3] = {Child01(1, 2), Child01(3, 4), Child01(5, 6)};  
  51.   
  52.     //不要用父类指针做赋值指针变量,去遍历一个子类的数组。  
  53.   
  54.     p = ca;  
  55.     c = ca;  
  56.   
  57.     p->f();  
  58.     c->f(); //有多态发生  
  59.   
  60. //  p++;  
  61. //  c++;  
  62. //   
  63. //  p->f();//有多态发生  
  64. //  c->f();  
  65.   
  66.     for (i=0; i<3; i++)  
  67.     {  
  68.         howToF(&(ca[i]));  
  69.     }  
  70.   
  71.       
  72.     system("pause");  
  73.     return 0;  
  74. }  

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值