C++旅程第八站------类的多态

这是她

The kind of beauty i want most is the hard-to-get kind that comes from within——strenght,courage,dignity.            ---Ruby Dee
                                                                                                                    多态
              分类：
              1、静态多态：函数重载和运算符重载属于静态多态，复用函数名
              2、动态多态：派生类和虚函数实现运行时多态

             静态多态和动态多态的区别：
            1、静态多态的函数地址早绑定，编译阶段确定函数地址；
            2、动态多态的函数地址晚绑定，运行阶段确定函数地址；

1. #include<iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class Figure
   
6. {
   
7.         public:
   
8.                 void Show_a()
   
9.                 {
   
10.                         cout << "Figure::Show_a!!!!!!!!" << endl;
    
11.                 }
    
12.                
    
13.                 //虚函数----------Show_b 函数就是虚函数  
    
14.                 //虚函数---在函数前面加上virtual关键字变成虚函数------这样编译器在编译的时候就不能确定函数调用了，在运行阶段确定
    
15.                 virtual void Show_b()
    
16.                 {
    
17.                         cout << "Figure::Show_b!!!!!!!!!!" << endl;
    
18.                 }
    
19. };
    
20. 
    
21. //函数重写-----函数返回值类型、函数名、参数列表  完全一致
    
22. class Diamond : public Figure
    
23. {
    
24.         public:
    
25.                 void Show_a()
    
26.                 {
    
27.                         cout << "Diamond::Show_a!!!!!!!!!" << endl;
    
28.                 }
    
29.                
    
30.                 void Show_b()
    
31.                 {
    
32.                         cout << "Diamond::Show_b!!!!!!!!!" << endl;
    
33.                 }
    
34. };
    
35. 
    
36. class Square : public Figure
    
37. {
    
38.         public:
    
39.                 void Show_a()
    
40.                 {
    
41.                         cout << "Square::Show_a!!!!!!!!!!!" << endl;
    
42.                 }
    
43.                
    
44.                 void Show_b()
    
45.                 {
    
46.                         cout << "Square::Show_b!!!!!!!!!!!" << endl;
    
47.                 }
    
48. };
    
49. 
    
50. //地址早绑定--在编译阶段就确定了函数地址
    
51. 
    
52. //父类的指针或引用---指向于类对象
    
53. void Doshow_a(Figure & figure)
    
54. {
    
55.         figure.Show_a();
    
56. }
    
57. 
    
58. //地址晚绑定--在运行阶段确定函数地址
    
59. //你想传入什么对象，就可以调用什么对象的函数
    
60. void Doshow_b(Figure * figure)
    
61. {
    
62.         figure->Show_b();
    
63. }
    
64. 
    
65. //动态多态满足条件：
    
66. //1、有继承关系；
    
67. //2、子类重写父类的虚函数；
    
68. 
    
69. //动态多态使用
    
70. //父类的指针或引用指向子类对象；
    
71. 
    
72. int main()
    
73. {
    
74.         Diamond d1;
    
75.         Doshow_a(d1);
    
76.         
    
77.         Square s1;
    
78.         Doshow_a(s1);
    
79.         
    
80.         cout << "---------------------------------------" << endl;
    
81.         
    
82.         Diamond d2;
    
83.         Doshow_b(&d2);
    
84.         
    
85.         Square s2;
    
86.         Doshow_b(&s2);
    
87.         
    
88.         return 0;
    
89. }

复制代码

         运行结果：

1. Figure::Show_a!!!!!!!!
   
2. Figure::Show_a!!!!!!!!
   
3. ---------------------------------------
   
4. Diamond::Show_b!!!!!!!!!
   
5. Square::Show_b!!!!!!!!!!!
   

复制代码

                                        渣渣来报道求大佬指点