C++类的继承和虚基类总结

原文地址：http://blog.youkuaiyun.com/armyshen/article/details/8685436

1、继承类之间的赋值

继承类之间的赋值，是指基类的对象赋值给子类的对象，或者子类赋值给基类的操作。一般情况下，只能是子类的对象赋值给基类对象

[cpp]  view plain copy print ?

1. class Father  
2. {  
3. public:  
4.     Father(){a = 100;}  
5.     ~Father(){}  
6.   
7.     const Father &operator=(const Father &m)//m是=号右边的对象    
8.     {    
9.         //自己给自己赋值的情况    
10.         if (this == &m)    
11.         {    
12.             return *this;    
13.         }    
14.         else    
15.         {    
16.             //把=号右边对象成员的值赋给左边对象成员    
17.             a = m.a;    
18.             return *this;    
19.         }    
20.     }   
21.   
22. private:  
23.     int a;  
24. };  
25.   
26. class Son:public Father  
27. {  
28. public:  
29.     Son(){b = 200;}  
30.     ~Son(){}  
31. private:  
32.     int b;  
33. };  
34. int main()  
35. {  
36.     Father father;  
37.     Son son;  
38.   
39.     //子类对象可以赋值给基类对象  
40.     father = son;//father.operator=(son);  
41.   
42.     //基类对象不能赋值给子类对象  
43.     /*赋值操作会调用operator=()函数，把father作为参数传递并给子类数据成员赋值，但是 
44.     通常子类成员包含从基类继承过来的和自己额外定义的成员，那么用基类对象给子类对象赋值 
45.     的时候就会出现问题，因为基类对象中并不包含子类额外定义数据成员*/  
46.     //son = father;  
47.   
48.     //基类对象指针可以指向子类对象  
49.     Father *pF = &son;  
50.   
51.     //子类对象指针不能指向父类  
52.     /*这样会使得把一部分不属于基类对象的内存也包括进来，在使用该指针的时候，常常会修改 
53.     基类对象之外的数据，造成严重错误*/  
54.     //Son *pS = &father;  
55.   
56.     //基类对象的引用可以作为子类对象的别名  
57.     Father &fat = son;  
58.   
59.     //子类对象的引用不能作为基类对象的别名，原因和指针相同  
60.     //Son &s = father;  
61.     return 0;  
62. }  

2、继承的构造和析构顺序

在构造一个子类的时候，会首先调用基类的构造函数(毕竟有父才有子嘛)对子类中基类那部分成员进行初始化，然后才会执行子类的构造函数，对子类其他成员进行初始化，如果这个基类仍是一个派生类，那么会一直往上执行，直到完成为止；析构的顺序和构造相反。

[cpp]  view plain copy print ?

1. class Grandfather  
2. {  
3. public:  
4.     Grandfather(){x = 300; cout<<"Grandfather构造函数"<<endl;}  
5.     ~Grandfather(){cout<<"Grandfather析构函数"<<endl;}  
6.   
7. private:  
8.     int x;  
9. };  
10.   
11. class Father:public Grandfather  
12. {  
13. public:  
14.     Father(){a = 100;cout<<"Father构造函数"<<endl;}  
15.     ~Father(){cout<<"Father析构函数"<<endl;}  
16. private:  
17.     int a;  
18. };  
19.   
20. class Son:public Father  
21. {  
22. public:  
23.     Son(){b = 200;cout<<"Son构造函数"<<endl;}  
24.     ~Son(){cout<<"Son析构函数"<<endl;}  
25. private:  
26.     int b;  
27. };  
28. int main()  
29. {  
30.     Son s;//先构造Grandfather，再构造Father，最后构造Son  
31.     //结束时，析构的顺序正好相反  
32.     return 0;  
33. }  

3、多重继承的构造和析构顺序

多重继承的构造是按照继承时的顺序进行的，析构的顺序和构造时的顺序相反

[cpp]  view plain copy print ?

1. class a  
2. {  
3. public:  
4.     a(){cout<<"a构造函数"<<endl;}  
5.     ~a(){cout<<"a析构函数"<<endl;}  
6. };  
7.   
8. class b  
9. {  
10. public:  
11.     b(){cout<<"b构造函数"<<endl;}  
12.     ~b(){cout<<"b析构函数"<<endl;}  
13. };  
14.   
15. class c  
16. {  
17. public:  
18.     c(){cout<<"c构造函数"<<endl;}  
19.     ~c(){cout<<"c析构函数"<<endl;}  
20. };  
21.   
22. class d:public b, public a, public c  
23. {  
24. public:  
25.     d(){cout<<"d构造函数"<<endl;}  
26.     ~d(){cout<<"d析构函数"<<endl;}  
27. };  
28.   
29. int main()  
30. {  
31.     //构造顺序：b、a、c、d  
32.     d s;  
33.     //析构顺序：d、c、a、b  
34.     return 0;  
35. }  

4、多重继承的二义性

如果派生类中有相同的函数定义，那么就会出现二义性问题，解决这个问题的方法就是在调用方法前面加上类型限定符。

如果子类里面有和基类里相同的函数，那么不会导致二义性，因为在调用函数的时候，编译器会先搜索子类中的函数，一旦

找到，调用即被确认下来。所以不会产生二义性。

[cpp]  view plain copy print ?

1. class a  
2. {  
3. public:  
4.     void print(){cout<<"a的函数"<<endl;}  
5. };  
6.   
7. class b  
8. {  
9. public:  
10.     void print(){cout<<"b的函数"<<endl;}  
11. };  
12.   
13. class c  
14. {  
15. public:  
16.     void print(){cout<<"c的函数"<<endl;}  
17. };  
18.   
19. class d:public b, public a, public c  
20. {  
21. public:  
22.     //继承关系最下面一个子类中有和父类相同函数的时候，不会产生二义性  
23.     //因为在调用的时候，编译器会优先在子类中搜索  
24.     void print(){cout<<"d的函数"<<endl;}  
25. };  
26.   
27. int main()  
28. {  
29.     d cd;  
30.     cd.b::print();//作用域标识符明确指定调用b的print()函数  
31.     cd.print();  
32.     return 0;  
33. }  

5、使用虚基类避免多重继承时的二义性

[cpp]  view plain copy print ?

1. class Human  
2. {  
3. public:  
4.     void Speak(){cout<<"会讲汉语"<<endl;}  
5. };  
6.   
7. class Mother:virtual public Human  
8. {  
9.   
10. };  
11.   
12. class Father:virtual public Human  
13. {  
14.   
15. };  
16.   
17. //Mother和Father将公共基类说明为虚基类(virtual)  
18. //因此，公共基类将只为条多继承路径的汇合处生成基类的一个实例  
19. //也就是说，只为Son(Son是Father和Mother的汇合)类生成一个Speak函数，从而避免二义性  
20. class Son:public Mother, public Father  
21. {  
22. };  
23.   
24. int main()  
25. {  
26.     Son son;  
27.     son.Speak();  
28.     return 0;  
29. }  

6、继承中的重载

当子类没有与基类拥有同名函数的时候，这时基类中的函数及其重载版本将会被子类全部继承过来。

当在子类中定义一个与基类同名的函数时，那么等于是告知编译器，用子类的函数覆盖掉基类的同名函数，同时将基类这个函数的重载版本隐藏起来。

[cpp]  view plain copy print ?

1. class Father  
2. {  
3. public:  
4.     void print(){cout<<"Father::print()"<<endl;}  
5.     void print(int i){cout<<"Father::print(int)"<<endl;}  
6. };  
7.   
8. class Son:public Father  
9. {  
10. public:  
11.     //覆盖掉基类同名函数，并且隐藏基类同名函数的重载版本  
12.     void print(){cout<<"Son::print()"<<endl;}  
13.     //const重载函数，会根据调用对象的版本选择  
14.     //非const对象，调用print()函数  
15.     //const对象，调用print()const函数  
16.     void print()const{cout<<"Son::print()const"<<endl;}  
17. };  
18.   
19. int main()  
20. {  
21.     Son so;  
22.     const Son s;  
23.     s.print();  
24.     so.print();  
25.     return 0;  
26. }