C++多态

1、多态引入---->数据的类型

        

       我们知道，不论我们定义一个怎么样的数据或者对象，我们都不会忘了它的类型，那么类型到底充当了一个怎样的角色呢？

        数据类型在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作。变量是用来存储值的所在处，它具有名字和数据类型。变量的数据类型决定了如何将代表这些值的位存储到计算机的内存中。在我看来，数据类型就好比一把尺子，它为我们在内存中存储数据提前做好了量度，告诉我们应该占用多大的内存。    

举例说明：

2、多态的概念

        所谓的多态性，就是不同的对象收到相同的消息时，产生不同的动作。直白点说，就是一个名字定义不同的函数，这些函数执行不同但又类似的操作，从而可以使用相同的方式来调用这些具有不同功能的同名函数，即“一个接口，多种方法”。

 

静态多态举例：重载函数、模板等

动态多态举例：虚函数等

虚函数的引入：在C++中，基类的对象指针可以指向它公有派生的对象，但是当其指向公有派生类对象时，它只能访问派生类中从基类继承来的成员，而不能访问公有派生类中定义的成员。

       使用virtual关键字修饰类的成员函数时，指明该函数为虚函数，派生类需要重新实现，编译器将实现动态绑定。

eg：

[cpp]  view plain  copy

 print ?

1. class Base  
2. {  
3. public:  
4.     Base(int x,int y)//构造函数  
5.     {  
6.         a = x;  
7.         b = y;  
8.     }  
9.     virtual void show()//虚函数  
10.     {  
11.         cout<<"Base::"<<a<<" "<<b<<endl;  
12.     }  
13. private:  
14.     int a;  
15.     int b;  
16. };  
17.   
18. class Derived:public Base  
19. {  
20. public:  
21.     Derived(int x,int y,int z):Base(x,y)//派生类的构造函数（为基类构造函数传参）  
22.     {  
23.         c = z;  
24.     }  
25.     void show()//重新定义虚函数show  
26.     {  
27.         cout<<"Derived::"<<c<<endl;  
28.     }  
29. private:  
30.     int c;  
31. };  
32.   
33. int main()  
34. {  
35.     Base b(60,60);//创建基类对象b  
36.     Base *pb;//创建基指针类pb  
37.     Derived d(10,20,30);//创建派生类对象d  
38.   
39.     pb = &b;//对象指针指向基类对象b  
40.     pb->show();//调用基类的虚函数show()  
41.     pb = &d;//对象指针指向派生类对象d  
42.     pb->show();//调用派生类的虚函数show()  
43.   
44.     system("pause");  
45.     return 0;  
46. }  

运行结果：

【动态绑定条件】
1、必须是虚函数
2、通过基类类型的引用或者指针调用虚函数

两个条件必须同时满足才可形成动态绑定

虚函数总结：

<1>由于虚函数使用的基础是赋值兼容规则，而赋值兼容规则的前提条件是派生类从其基类公有派生，所以使用虚函数来实现多态时，派生类必须从它的基类公有派生。

<2>必须首先在基类中定义虚函数。

<3>在派生类中对基类中声明的虚函数进行重定义时，关键字virtual可以加也可以不加。为了不引起混乱，最好加上。

<4>虽然使用对象名和点运算符的方式也可以调用虚函数，但只有通过基类指针或引用访问虚函数时才能获得运行时的多态性。

<5>一个虚函数无论被继承多少次，它仍然保持其虚函数的特性。

<6>虚函数必须是其所在类的成员函数，而不能是友元函数，也不能是静态成员函数。

<7>内联函数不能是虚函数，因为内联函数是不能在运行中动态确定其位置的。

<8>构造函数不能是虚函数，但是析构函数可以是虚函数，而且通常说明为虚函数。

3、函数重载&同名隐藏&重写：

函数重载：

[cpp]  view plain  copy

 print ?

1. //函数重载  
2. int add(int x,int y)  
3. {  
4.     return x+y;  
5. }  
6. double add(float a,float b)  
7. {  
8.     return a+b;  
9. }  
10. int main()  
11. {  
12.     int a = 3,b = 5;  
13.     float x = 3.14f,y = 6.8f;  
14.     int ret1 = add(a,b);  
15.     cout<<"int----"<<ret1<<endl;  
16.     double ret2 = add(x,y);  
17.     cout<<"double----"<<ret2<<endl;  
18.     system("pause");  
19.     return 0;  
20. }  

运行结果：

重写举例：

[cpp]  view plain  copy

 print ?

1. //重写  
2. class Base  
3. {  
4. public:  
5.     virtual void show(int x,int y)//虚函数  
6.     {  
7.         a = x;  
8.         b = y;  
9.         cout<<"Base::"<<a<<" "<<b<<endl;  
10.     }  
11. private:  
12.     int a;  
13.     int b;  
14. };  
15.   
16. class Derived:public Base  
17. {  
18. public:  
19.     void show(int x,int y)//重新定义虚函数show  
20.     {  
21.         c = x + y;  
22.         cout<<"Derived::"<<c<<endl;  
23.     }  
24. private:  
25.     int c;  
26. };  
27.   
28. int main()  
29. {  
30.     Base b;//创建基类对象b  
31.     Derived d;//创建派生类对象d  
32.       
33.     b.show(10,20);  
34.     d.Derived::show(30,40);  
35.     system("pause");  
36.     return 0;  
37. }  

运行结果：

协变：与重写的条件基本一样，唯一不同的是协变的返回值可以不同，基类返回基类的指针/引用，派生类返回派生类的指针/引用。

[cpp]  view plain  copy

 print ?

1. <pre name="code" class="cpp">//重写（协变）  
2. class Base  
3. {  
4. public:  
5.     virtual Base& fun(int x,int y)//虚函数  
6.     {  
7.         a = x;  
8.         b = y;  
9.         cout<<"Base::"<<a<<" "<<b<<endl;  
10.         return *this;  
11.     }  
12. private:  
13.     int a;  
14.     int b;  
15. };  
16.   
17. class Derived:public Base  
18. {  
19. public:  
20.     Derived& fun(int x,int y)//重新定义虚函数show  
21.     {  
22.         c = x + y;  
23.         cout<<"Derived::"<<c<<endl;  
24.         return *this;  
25.     }  
26. private:  
27.     int c;  
28. };  
29.   
30. int main()  
31. {  
32.     Base b;//创建基类对象b  
33.     Derived d;//创建派生类对象d  
34.       
35.     b.fun(10,20);  
36.     d.Derived::fun(30,40);  
37.     system("pause");  
38.     return 0;  
39. }  

运行结果：

同名隐藏举例：

[cpp]  view plain  copy

 print ?

1. <pre name="code" class="cpp">//同名隐藏  
2. class Base  
3. {  
4. public:  
5.     int show()  
6.     {  
7.         cout<<"Base::show()"<<endl;  
8.         return 0;  
9.     }  
10. };  
11.   
12. class Derived:public Base  
13. {  
14. public:  
15.     void show()  
16.     {  
17.         cout<<"Derived::show()"<<endl;  
18.     }  
19. };  
20.   
21. int main()  
22. {  
23.     Derived d;//创建派生类对象d  
24.   
25.     d.show();//调用派生类自己的同名函数  
26.     d.Base::show();//调用基类的同名函数  
27.     system("pause");  
28.     return 0;  
29. }  

运行结果：

4、纯虚函数&抽象类

纯虚函数：

定义：纯虚函数是在声明虚函数时被“初始化”为0的函数。

一般格式：virtual 函数类型   函数名（参数表）= 0；

作用：在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行重新定义。

纯虚函数举例：

[cpp]  view plain  copy

 print ?

1. <pre name="code" class="cpp">class Circle//基类  
2. {  
3. public:  
4.     void setr(int x)  
5.     {  
6.         r = x;  
7.     }  
8.     virtual void show() = 0;//定义纯虚函数  
9. protected:  
10.     int r;  
11. };  
12. class Area:public Circle//派生类  
13. {  
14. public:  
15.     void show()//重新定义虚函数show求圆形面积  
16.     {  
17.         cout<<"Area is "<<3.14*r*r<<endl;  
18.     }  
19. };  
20. int main()  
21. {  
22.     Circle* p;//基类指针  
23.     Area a;//派生类对象a  
24.     a.setr(5);  
25.     p = &a;  
26.     p->show();//计算圆形面积  
27.   
28.     system("pause");  
29.     return 0;  
30. }  

运行结果：

抽象类：包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。纯虚函数在派生类中重新定义以后，派生类才能实例化出对象。

建立抽象类的目的：用它作为基类去建立派生类，抽象类作为一种基本类型提供给用户，用户在这个基础上根据自己的需要定义出功能各异的派生类，并用这些派生类去建立对象。

抽象类使用规则：

<1>抽象类只能作为其他类的基类来使用，不能建立抽象类对象。

<2>不允许从具体类派生出抽象类。

<3>抽象类不能用作函数的参数类型、函数的返回类型或者显式转换的类型。

<4>可以声明指向抽象类的指针或引用，此指针可以指向它的派生类，进而实现多态性。

<5>如果派生类中没有定义纯虚函数的实现，而派生类只是继承基类的纯虚函数，则这个派生类仍然是一个抽象类。如果派生类给出了基类纯虚函数的实现，则该派生类不再是抽象类，而是可以建立对象的具体类。

5、虚表剖析

       对于有虚函数的类（即抽象类），编译器都会维护一张虚表，对象的前四个字节就是指向虚表的指针，虚表中按照虚函数在类中的声明顺序依次存放了各个虚函数的地址。

eg1:

//只有基类的虚函数

[cpp]  view plain  copy

 print ?

1. class B  
2. {  
3. public:  
4.     virtual void Funtest1()  
5.     {  
6.         cout<<"B::Funtest1"<<endl;  
7.     }  
8.     virtual void Funtest2()  
9.     {  
10.         cout<<"B::Funtest2"<<endl;  
11.     }  
12.     virtual void Funtest3()  
13.     {  
14.         cout<<"B::Funtest3"<<endl;  
15.     }  
16.     virtual void Funtest4()  
17.     {  
18.         cout<<"B::Funtest4"<<endl;  
19.     }  
20. };  
21. typedef void (*Vpf)();//函数指针  
22.   
23. void PrintVft()//打印虚表  
24. {  
25.     B b;  
26.     Vpf* fun = (Vpf*)*(int*)&b;  
27.   
28.     while(*fun)  
29.     {  
30.         (*fun)();  
31.         fun++;  
32.     }  
33. }  
34. int main()  
35. {  
36.     cout<<sizeof(B)<<endl;  
37.     PrintVft();  
38.     system("pause");  
39.     return 0;  
40. }  

该段代码中包含一个类，类中有4个虚函数，在打印虚表的函数中，我们创建了一个B类的对象。注意包含虚函数的类如果没有显示定义构造函数，编译器会自动替它合成，并且将虚表指针放在对象的前4个字节。

运行过程截图：

内存分析：

运行结果：

eg2:

[cpp]  view plain  copy

 print ?

1. //没有覆盖且派生类没有新添加虚函数  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.     virtual void Funtest2()  
10.     {  
11.         cout<<"B::Funtest2"<<endl;  
12.     }  
13.     virtual void Funtest3()  
14.     {  
15.         cout<<"B::Funtest3"<<endl;  
16.     }  
17.     virtual void Funtest4()  
18.     {  
19.         cout<<"B::Funtest4"<<endl;  
20.     }  
21. };  
22.   
23. class D:public B  
24. {};  
25. typedef void (*Vpf)();//函数指针  
26.   
27. void PrintVft()//打印虚表  
28. {  
29.     D d;//创建派生类对象d  
30.     Vpf* fun = (Vpf*)*(int*)&d;  
31.   
32.     while(*fun)  
33.     {  
34.         (*fun)();  
35.         fun++;  
36.     }  
37. }  
38. int main()  
39. {  
40.     cout<<sizeof(B)<<endl;  
41.     cout<<sizeof(D)<<endl;  
42.     PrintVft();  
43.     system("pause");  
44.     return 0;  
45. }  

运行过程截图：

内存分析：

运行结果：

结论：如果派生类没有重写基类的虚函数，并且没有添加自己的虚函数，则直接继承基类的虚函数。

eg3:

[cpp]  view plain  copy

 print ?

1. //没有覆盖且派生类新添加虚函数  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.     virtual void Funtest2()  
10.     {  
11.         cout<<"B::Funtest2"<<endl;  
12.     }  
13. };  
14.   
15. class D:public B  
16. {  
17. public:  
18.     virtual void Funtest3()  
19.     {  
20.         cout<<"D::Funtest3"<<endl;  
21.     }  
22.     virtual void Funtest4()  
23.     {  
24.         cout<<"D::Funtest4"<<endl;  
25.     }  
26. };  
27. typedef void (*Vpf)();//函数指针  
28.   
29. void PrintVft()//打印虚表  
30. {  
31.     D d;//创建派生类对象d  
32.     Vpf* fun = (Vpf*)*(int*)&d;  
33.   
34.     while(*fun)  
35.     {  
36.         (*fun)();  
37.         fun++;  
38.     }  
39. }  
40. int main()  
41. {  
42.     cout<<sizeof(B)<<endl;  
43.     cout<<sizeof(D)<<endl;  
44.     PrintVft();  
45.     system("pause");  
46.     return 0;  
47. }  

内存分析：

运行结果：

结论：要是派生类新增了虚函数，则虚表先存放从基类继承来的虚函数，再存放派生类自己的虚函数。

eg4:

[cpp]  view plain  copy

 print ?

1. //有部分覆盖且派生类新添加虚函数  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.     virtual void Funtest2()  
10.     {  
11.         cout<<"B::Funtest2"<<endl;  
12.     }  
13. };  
14.   
15. class D:public B  
16. {  
17. public:  
18.     virtual void Funtest3()  
19.     {  
20.         cout<<"D::Funtest3"<<endl;  
21.     }  
22.     virtual void Funtest1()//重写基类的虚函数Funtest1()  
23.     {  
24.         cout<<"D::Funtest1"<<endl;  
25.     }  
26.     virtual void Funtest4()  
27.     {  
28.         cout<<"D::Funtest4"<<endl;  
29.     }  
30. };  
31. typedef void (*Vpf)();//函数指针  
32.   
33. void PrintVft()//打印虚表  
34. {  
35.     D d;//创建派生类对象d  
36.     Vpf* fun = (Vpf*)*(int*)&d;  
37.   
38.     while(*fun)  
39.     {  
40.         (*fun)();  
41.         fun++;  
42.     }  
43. }  
44. int main()  
45. {  
46.     cout<<sizeof(B)<<endl;  
47.     cout<<sizeof(D)<<endl;  
48.     PrintVft();  
49.     system("pause");  
50.     return 0;  
51. }  

内存分析：

运行结果：

结论：有部分重写的虚函数，在打印派生类的虚表时，先打印基类的虚表，在派生类中重写了的虚函数将替换对应位置基类自己的虚函数，最后是派生类新添加的虚函数。

eg5:

[cpp]  view plain  copy

 print ?

1. //全部覆盖且派生类新添加虚函数  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.     virtual void Funtest2()  
10.     {  
11.         cout<<"B::Funtest2"<<endl;  
12.     }  
13. };  
14.   
15. class D:public B  
16. {  
17. public:  
18.     virtual void Funtest2()//重写基类的虚函数Funtest2()  
19.     {  
20.         cout<<"D::Funtest2"<<endl;  
21.     }  
22.     virtual void Funtest3()  
23.     {  
24.         cout<<"D::Funtest3"<<endl;  
25.     }  
26.     virtual void Funtest1()//重写基类的虚函数Funtest1()  
27.     {  
28.         cout<<"D::Funtest1"<<endl;  
29.     }  
30.     virtual void Funtest4()  
31.     {  
32.         cout<<"D::Funtest4"<<endl;  
33.     }  
34. };  
35. typedef void (*Vpf)();//函数指针  
36.   
37. void PrintVft()//打印虚表  
38. {  
39.     D d;//创建派生类对象d  
40.     Vpf* fun = (Vpf*)*(int*)&d;  
41.   
42.     while(*fun)  
43.     {  
44.         (*fun)();  
45.         fun++;  
46.     }  
47. }  
48. int main()  
49. {  
50.     cout<<sizeof(B)<<endl;  
51.     cout<<sizeof(D)<<endl;  
52.     PrintVft();  
53.     system("pause");  
54.     return 0;  
55. }  

内存分析：

运行结果：

结论：当基类的虚函数全部在派生类中重写时，此时打印派生类的虚表，全部打印基类中重写的虚函数，且顺序与基类中虚函数声明的顺序保持一致，与基类中重写的顺序无关，最后在添上派生类新添加的虚函数。

多继承：

eg6:

[cpp]  view plain  copy

 print ?

1. //没有覆盖的多继承的虚表  
2. class B1  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B1::Funtest1"<<endl;  
8.     }  
9. };  
10. class B2  
11. {  
12.     virtual void Funtest2()  
13.     {  
14.         cout<<"B2::Funtest2"<<endl;  
15.     }  
16. };  
17. class D:public B1,public B2  
18. {  
19. public:  
20.     virtual void Funtest3()//新增派生类的虚函数Funtest3()  
21.     {  
22.         cout<<"D::Funtest3"<<endl;  
23.     }  
24. };  
25. typedef void (*Vpf)();//函数指针  
26.   
27. void PrintVft()//打印虚表  
28. {  
29.   
30.     D d;//创建派生类对象d  
31.     Vpf* fun = (Vpf*)*(int*)&d;  
32.   
33.     cout<<"D"<<endl;  
34.     while(*fun)  
35.     {  
36.         (*fun)();  
37.         fun++;  
38.     }  
39.   
40.     B2 &b2 = d;//打印B2的虚表  
41.     fun = (Vpf*)*(int*)&b2;  
42.     while(*fun)  
43.     {  
44.         (*fun)();  
45.         fun++;  
46.     }  
47. }  
48. int main()  
49. {  
50.     cout<<sizeof(B1)<<endl;  
51.     cout<<sizeof(D)<<endl;  
52.     PrintVft();  
53.     system("pause");  
54.     return 0;  
55. }  

运行过程截图：

内存分析：

运行结果：

结论：没有重写的多继承的虚表，先按照继承次序打印第一个基类的虚函数表，再打印派生类新添加的虚函数表，然后再接着打印第二个继承基类的虚表，直至所有基类的虚函数表打印完成。

eg7:

[cpp]  view plain  copy

 print ?

1. //部分覆盖的多继承的虚表  
2. class B1  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B1::Funtest1"<<endl;  
8.     }  
9. };  
10. class B2  
11. {  
12.     virtual void Funtest2()  
13.     {  
14.         cout<<"B2::Funtest2"<<endl;  
15.     }  
16. };  
17. class D:public B1,public B2  
18. {  
19. public:  
20.     virtual void Funtest2()  
21.     {  
22.         cout<<"D::Funtest2"<<endl;  
23.     }  
24.     virtual void Funtest3()//新增派生类的虚函数Funtest3()  
25.     {  
26.         cout<<"D::Funtest3"<<endl;  
27.     }  
28. };  
29. typedef void (*Vpf)();//函数指针  
30.   
31. void PrintVft()//打印虚表  
32. {  
33.   
34.     D d;//创建派生类对象d  
35.     Vpf* fun = (Vpf*)*(int*)&d;  
36.   
37.     cout<<"D"<<endl;  
38.     while(*fun)  
39.     {  
40.         (*fun)();  
41.         fun++;  
42.     }  
43.   
44.     B2 &b2 = d;//打印B2的虚表  
45.     fun = (Vpf*)*(int*)&b2;  
46.     while(*fun)  
47.     {  
48.         (*fun)();  
49.         fun++;  
50.     }  
51. }  
52. int main()  
53. {  
54.     cout<<sizeof(B1)<<endl;  
55.     cout<<sizeof(D)<<endl;  
56.     PrintVft();  
57.     system("pause");  
58.     return 0;  
59. }  

内存分析：

运行结果：

结论：有重写的多继承的虚表，先按照继承次序打印第一个基类的虚函数表（若重写，则用派生类的对应虚函数替换），再打印派生类新添加的虚函数表，然后再接着打印第二个继承基类的虚表，直至所有基类的虚函数表打印完成，（若重写，则用派生类的对应虚函数替换）。

虚拟继承：

eg1:

[cpp]  view plain  copy

 print ?

1. //带构造函数的虚拟继承  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.     virtual void Funtest2()  
10.     {  
11.         cout<<"B::Funtest2"<<endl;  
12.     }  
13. };  
14. class D:virtual public B  
15. {  
16. public:  
17.     D()  
18.     {}//派生类构造函数  
19.     virtual void Funtest2()//重写基类的虚函数Funtest2()  
20.     {  
21.         cout<<"D::Funtest2"<<endl;  
22.     }  
23.     virtual void Funtest3()//新增派生类的虚函数Funtest3()  
24.     {  
25.         cout<<"D::Funtest3"<<endl;  
26.     }  
27. };  
28. typedef void (*Vpf)();//函数指针  
29.   
30. void PrintVft()//打印虚表  
31. {  
32.   
33.     D d;//创建派生类对象d  
34.     Vpf* fun = (Vpf*)*(int*)&d;  
35.   
36.     cout<<"D"<<endl;  
37.     while(*fun)  
38.     {  
39.         (*fun)();  
40.         fun++;  
41.     }  
42.   
43.     cout<<endl<<endl;  
44.   
45.     fun = (Vpf*)*((int*)&d + 3);  
46.     while(*fun)  
47.     {  
48.         (*fun)();  
49.         fun++;  
50.     }  
51. }  
52. int main()  
53. {  
54.     cout<<sizeof(B)<<endl;  
55.     cout<<sizeof(D)<<endl;  
56.     PrintVft();  
57.     system("pause");  
58.     return 0;  
59. }  

内存分析：

运行结果：

eg2:

[cpp]  view plain  copy

 print ?

1. <pre name="code" class="cpp">//部分覆盖的虚拟继承  
2. class B1  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B1::Funtest1"<<endl;  
8.     }  
9.     virtual void Funtest2()  
10.     {  
11.         cout<<"D::Funtest2"<<endl;  
12.     }  
13. };  
14. class D:virtual public B1  
15. {  
16. public:  
17.     virtual void Funtest2()//重写基类的虚函数Funtest2()  
18.     {  
19.         cout<<"D::Funtest2"<<endl;  
20.     }  
21.     virtual void Funtest3()//新增派生类的虚函数Funtest3()  
22.     {  
23.         cout<<"D::Funtest3"<<endl;  
24.     }  
25. };  
26. typedef void (*Vpf)();//函数指针  
27.   
28. void PrintVft()//打印虚表  
29. {  
30.   
31.     D d;//创建派生类对象d  
32.     Vpf* fun = (Vpf*)*(int*)&d;  
33.   
34.     cout<<"D"<<endl;  
35.     while(*fun)  
36.     {  
37.         (*fun)();  
38.         fun++;  
39.     }  
40.   
41.     cout<<endl<<endl;  
42.   
43.     fun = (Vpf*)*((int*)&d + 2);  
44.     while(*fun)  
45.     {  
46.         (*fun)();  
47.         fun++;  
48.     }  
49. }  
50. int main()  
51. {  
52.     cout<<sizeof(B1)<<endl;  
53.     cout<<sizeof(D)<<endl;  
54.     PrintVft();  
55.     system("pause");  
56.     return 0;  
57. }  

内存分析：

运行结果：

结论：带有重写的虚拟继承中，先打印派生类新添加的虚函数表，再打印从基类继承来的虚函数表，重写的部分用派生类对应的虚函数替换。

菱形继承：

1、非虚拟继承

[cpp]  view plain  copy

 print ?

1. //菱形继承  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.   
10.     int _data1;  
11. };  
12. class C1:public B  
13. {  
14. public:  
15.     virtual void Funtest2()//新添  
16.     {  
17.         cout<<"C1::Funtest2"<<endl;  
18.     }  
19.   
20.     int _data2;  
21. };  
22. class C2:public B  
23. {  
24. public:  
25.     virtual void Funtest3()//新添加虚函数  
26.     {  
27.         cout<<"C2::Funtest3"<<endl;  
28.     }  
29.     virtual void Funtest1()//重写  
30.     {  
31.         cout<<"C2::Funtest1"<<endl;  
32.     }  
33.   
34.     int _data3;  
35. };  
36. class D:public C1,public C2  
37. {  
38. public:  
39.     virtual void Funtest3()//重写基类的虚函数Funtest3()  
40.     {  
41.         cout<<"D::Funtest3"<<endl;  
42.     }  
43.     virtual void Funtest4()//新添加虚函数Funtest4()  
44.     {  
45.         cout<<"D::Funtest4"<<endl;  
46.     }  
47.   
48.     int _data4;  
49. };  
50.   
51. typedef void (*Vpf)();//函数指针  
52.   
53. void PrintVft()//打印虚表  
54. {  
55.   
56.     D d;//创建派生类对象d  
57.     d.C1::_data1 = 1;  
58.     d.C2::_data1 = 5;  
59.     d._data2 = 2;  
60.     d._data3 = 3;  
61.     d._data4 = 4;  
62.     Vpf* fun = (Vpf*)*(int*)&d;  
63.   
64.     cout<<"D"<<endl;  
65.     while(*fun)  
66.     {  
67.         (*fun)();  
68.         fun++;  
69.     }  
70.       
71.     cout<<endl<<endl;  
72.   
73.     fun = (Vpf*)*((int*)&d + 3);//向后偏移12个字节找到C2的虚表指针  
74.     while(*fun)  
75.     {  
76.         (*fun)();  
77.         fun++;  
78.     }  
79. }  
80. int main()  
81. {  
82.     cout<<"B  "<<sizeof(B)<<endl;  
83.     cout<<"C1  "<<sizeof(C1)<<endl;  
84.     cout<<"C2  "<<sizeof(C2)<<endl;  
85.     cout<<"D  "<<sizeof(D)<<endl<<endl;  
86.     PrintVft();  
87.     system("pause");  
88.     return 0;  
89. }  

分析截图：

运行结果：

结论：非虚拟的菱形继承中，派生类的对象的内存分布结构为：先存放第一个基类的虚表指针和从最基类那继承来的数据和基类自己的数据，接着将派生类新添的虚函数按声明顺序放在其虚表末尾，接着存放第二个基类的虚表指针和从最基类那继承来的数据和基类自己的数据，最后是派生类自己的数据部分。

2、虚拟继承：

[cpp]  view plain  copy

 print ?

1. //菱形继承（虚拟继承）  
2. class B  
3. {  
4. public:  
5.     virtual void Funtest1()  
6.     {  
7.         cout<<"B::Funtest1"<<endl;  
8.     }  
9.   
10.     int _data1;  
11. };  
12. class C1:virtual public B  
13. {  
14. public:  
15.     virtual void Funtest2()//新添  
16.     {  
17.         cout<<"C1::Funtest2"<<endl;  
18.     }  
19.   
20.     int _data2;  
21. };  
22. class C2:virtual public B  
23. {  
24. public:  
25.     virtual void Funtest3()//新添加虚函数  
26.     {  
27.         cout<<"C2::Funtest3"<<endl;  
28.     }  
29.     virtual void Funtest1()//重写  
30.     {  
31.         cout<<"C2::Funtest1"<<endl;  
32.     }  
33.   
34.     int _data3;  
35. };  
36. class D:public C1,public C2  
37. {  
38. public:  
39.     virtual void Funtest3()//重写基类的虚函数Funtest3()  
40.     {  
41.         cout<<"D::Funtest3"<<endl;  
42.     }  
43.     virtual void Funtest4()//新添加虚函数Funtest4()  
44.     {  
45.         cout<<"D::Funtest4"<<endl;  
46.     }  
47.   
48.     int _data4;  
49. };  
50.   
51. typedef void (*Vpf)();//函数指针  
52.   
53. void PrintVft()//打印虚表  
54. {  
55.   
56.     D d;//创建派生类对象d  
57.     d._data1 = 1;  
58.     d._data2 = 2;  
59.     d._data3 = 3;  
60.     d._data4 = 4;  
61.     Vpf* fun = (Vpf*)*(int*)&d;  
62.   
63.     cout<<"D"<<endl;  
64.     while(*fun)  
65.     {  
66.         (*fun)();  
67.         fun++;  
68.     }  
69.   
70.     cout<<endl<<endl;  
71.   
72.     fun = (Vpf*)*((int*)&d + 3);//向后偏移12个字节找到C2的虚表指针  
73.     while(*fun)  
74.     {  
75.         (*fun)();  
76.         fun++;  
77.     }  
78.   
79.     cout<<endl<<endl;  
80.   
81.     fun = (Vpf*)*((int*)&d + 7);//向后偏移28个字节找到B的虚表指针  
82.     while(*fun)  
83.     {  
84.         (*fun)();  
85.         fun++;  
86.     }  
87. }  
88. int main()  
89. {  
90.     cout<<"B  "<<sizeof(B)<<endl;  
91.     cout<<"C1  "<<sizeof(C1)<<endl;  
92.     cout<<"C2  "<<sizeof(C2)<<endl;  
93.     cout<<"D  "<<sizeof(D)<<endl<<endl;  
94.     PrintVft();  
95.     system("pause");  
96.     return 0;  
97. }  

分析过程：

运行结果：