C++继承

继承

1.继承的概念

　　继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

2.继承的定义

 1 class Base{
 2     //基类/父类
 3     public:
 4         void SetBase(int prib, int prob,int prub){
 5             _prib=prib;
 6             _prob=prob;
 7             _prub=prub;
 8         }
 9     private:
10         int _prib;
11     protected:
12         int _prob;
13     public:
14         int _prub;
15 };
16 
17 class Derived :继承权限 Base{
18     //子类/派生类  紫色为继承列表  
19 
20 };
21 
22 class Derived :public Base{  //共有继承
23     //子类/派生类    
24 };

3.不同继承方式下的访问权限

　　（1）public的继承方式，基类中的成员（成员变量，成员函数）已经被继承到派生类中

　　基类中不同访问权限的成员在派生类中的访问权限没有发生改变

　　注意：基类中的私有成员变量在派生类中不可见

　　（2）protected的继承方式，基类中的成员（成员变量，成员函数）已经被继承到派生类中

　　基类中不同访问权限的成员在派生类中的访问权限发生改变

　　基类中的public的成员变量在派生类中不可被访问权限被改为protected

　　基类中protected的成员变量在子类中任然是protected

　　基类中的private的成员变量在子类中不可见

　　（3）private的继承方式,基类中的成员变量已经被继承到派生类中

　　基类中public的成员变量在子类中权限为private

　　基类中的protected的成员变量在子类中的权限为private

　　基类中的private的成员变量在子类中不可见

注意：

　　基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

　　基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

　　（4）使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

4.基类和派生类对象赋值转换

　　派生类的对象可以赋值给基类的对象、基类的指针、基类的引用；这里有个形象的说法就是将派生类中从基类继承过来的部分进行切分或分隔，将属于父类的那一部分赋值给基类的对象，基类的指针或者引用；基类对象不能给派生类赋值；要理解这个问题，还得从赋值的本质入手。赋值实际上是向内存填充数据，当数据较多时很好处理，舍弃即可；举例子，B=D 时，成员 b 是多余的，会被直接丢掉，所以不会发生赋值错误。但当数据较少时，问题就很棘手，编译器不知道如何填充剩下的内存；上例中，D=B 时，编译器不知道该如何给变量 b 赋值，所以会发生错误。

　　基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。不要使用派生类的指针指向基类的对象—–不安全（强制类型转换）

5.继承中的作用域

　　在继承体系中基类和派生类都有独立的作用域。子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问），同名的成员函数继承到了子类中，但不会构成重载，因为作用域不同，实际的函数名不同，前面有”作用域::”；需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏，与函数类型是否相同没有任何关系。注意在实际中在继承体系里面最好不要定义同名的成员

　　同名隐藏：基类与派生类中具有相同名称的成员（成员变量，成员函数），使用派生类对象访问相同名称的成员时，优先访问派生类的同名成员，在同名成员前加基类的名称与作用域限定符可以访问派生类中继承的基类的同名的成员

6.派生类的默认成员函数

　　1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用

　　2.派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化

　　3.派生类的operator=必须要调用基类的operator=完成基类的复制

　　4.派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序

　　5.派生类对象初始化先调用基类构造再调派生类构造（先定义那个类的对象，则先调用那个类的构造函数，先创建派生类的对象，则先调用派生类的构造函数，在派生类构造函数初始化列表的地方再构造好基类的成员，接着初始化派生类的成员）

　　6.派生类对象析构清理先调用派生类析构再调基类的析构（在派生类析构函数组后一条语句后增加了一条调用基类析构函数的语句call ~Base();）

 1 class Base{
 2 public:
 3     Base(int b):_b(b){}
 4     Base(const Base& b)//拷贝构造函数
 5         :_b(b._b)
 6         {}
 7     Base& operator=(const Base& b){
 8         if(this!=&b){
 9             _b=b._b;
10         }
11         return *this;
12     }
13     ~Base(){
14     }
15 protected:
16     int _b;
17 };
18 //////////////////////////////////////////////////////////////////////////
19 #if 0
20 class Derived:public Base{
21 private:
22     int _d;
23 };
24 
25 int main(){
26     Derived d;
27     //若没有定义对象，则编译通过，没有问题
28     //若定义了对象，则报错，编译不通过
29     //原因是派生类没有显示定义构造函数，因此在定义对象时，由于派生类中基类部分初始化时调用基类的构造函数，但基类的构造函数需要参数，所以编译器尝试生成默认构造函数时无法确定传什么参数，因此报错。
30 但如果基类的构造函数的参数有缺省值，则编译通过
31     return 0;
32 }
33 #endif
34 //////////////////////////////////////////////////////////////////////////
35 解决上述问题的方法时显示定义派生类的构造函数并将基类的参数传过去
36 class Derived:public Base{
37     Derived(int b,int d)
38         :Base(b)
39         ,_d(d)
40         {}
41     Derived(const Derived& d)
42         :Base(d._b)
43         ,_d(d._d)
44         {}
45     Derived& operator=(const Derived& d){
46         if(this!=&d){
47             Base::operator(d._b);//派生类的赋值运算符的重载必须调用基类的运算符的重
48             _d=d._d
49         }
50     }
51 private:
52     int _d;
53 };
54 int main(){
55     Derived d(10,20);
56         先定义那个类的对象，则先调用那个类的构造函数，先创建派生类的对象，则先调用派生类的构造函数，在派生类构造函数初始化列表的地方再构造好基类的成员，接着初始化派生类的成员
57         在派生类析构函数组后一条语句后增加了一条调用基类析构函数的语句call ~Base();
58         
59     Derived d1(d);
60     Derived d2(d1);
61     d1=d2;
62     return 0;
63 }

 1 实现无法被继承的类
 2 // C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
 3 class NonInherit
 4 {
 5 public:
 6     static NonInherit GetInstance()
 7     {
 8         return NonInherit();
 9     }
10 private:
11     NonInherit()
12     {}
13 };
14 // C++11给出了新的关键字final禁止继承
15 class NonInherit final{};

7.继承和友元

　　友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

8.继承与静态成员

　　基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例

9.不同的继承方式

（1）单继承

　　一个类只有一个基类　　class Base;_b class Derived:public Base; _d;

（2）多继承

　　一个类有多个基类（即继承自多个类）

 1 class B1{
 2 public:
 3     int _b1;
 4 };
 5 
 6 class B2{
 7 public:
 8     int _b2;
 9 };
10 
11 class D:public B1,public B2{
12 public:
13     int _d;
14 };
15 
16 int main(){
17     cout<<sizeof(D)<<endl;
18     D d;
19     d._b1=1;
20     d._b2=2;
21     d._d=3;
22     return 0;
23 }

（3）菱形继承（钻石继承）

 1 class B{
 2 public:
 3     int _b;
 4 };
 5 class C1:public B{
 6 public:
 7     int _c1;
 8 };
 9 class C2:public B{
10 public:
11     int _c2;
12 }；
13 class D:public C1,public C2{
14 public:
15     int _d;
16 };
17 
18 int main(){
19     D d;
20     //d._b=1;//编译出错，对_b的访问不明确，菱形继承的二义性，即_b在C1，C2中都有
21     d.C1::_b=1;
22     d.C2::_b=2;
23     d._d=3;
24     d._c1=4;
25     d._c2=5;
26     同理，成员函数也有二义性的问题
27     用菱形虚拟继承解决菱形继承的二义性问题
28     return 0;
29 }