C++中的继承

继承的概念

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

继承的定义格式

//一个简单的Person类作为基类
class Person
{
public:
  void Print()
  {
   cout << "name:" << _name << endl;
   cout << "age:" << _age << endl;
  }
protected:
   string _name = "peter"; // 姓名
   int _age = 18; // 年龄
};

//定义一个Student类继承基类
class Student : public Person
{
 protected:
   int _stuid; // 学号
};

继承后Person的成员（成员函数+成员变量）都会变成Student的一部分。这里体现出了Student复用了Person的成员

继承类格式：

继承方式有 public继承 protected继承 private继承

继承方式

注意：

1. 不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类。
   的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示写出继承方式。
5. 在实际运用中一般使用public继承就能满足绝大多数需求。

切片

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

基类对象不能赋值给派生类对象

通过强制类型转换，也可以将基类指针强制转换成派生类指针。只是在这种情况下，程序员需要保证被转换的基类指针本来就指向一个派生类的对象，这样才是安全的，否则很容易出错。

举例说明：

class Person
{
protected :
 string _name; // 姓名
 string _sex; // 性别
 int _age; // 年龄
};
class Student : public Person
{
public :
 int _No ; // 学号
};
void Test ()
{
 Student sobj ;
 // 1.子类对象可以赋值给父类对象/指针/引用
 Person pobj = sobj ;
 Person* pp = &sobj;
 Person& rp = sobj;
 
 //2.基类对象不能赋值给派生类对象
 sobj = pobj;
 
 // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
 pp = &sobj
 Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
 ps1->_No = 10;
 
 pp = &pobj;
 Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但基类指针之前指向的是基类对象
                               //会存在越界访问的问题
 ps2->_No = 10; 
 }

作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类的同名成员，这种情况叫隐藏，也叫重定
   义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 实际中最好不要定义同名的成员。

派生类的默认成员函数

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类那一部分成员的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类那一部分成员的复制。
4. 派生类的析构函数在被调用完成后，自动调用基类的析构函数清理基类那一部分成员。
   对象先清理派生类成员再清理基类成员
5. 派生类对象初始化先调用基类构造再调派生类构造，析构相反。

继承中的友元和静态成员

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

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

菱形继承和虚拟继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况

菱形继承的问题：可以看出菱形继承有数据冗余和二义性的问题。在 D 的对象中 A 成员会有两份。

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在 B 和 C 继承 A 时使用虚拟继承，即可解决问题

虚拟继承解决数据冗余和二义性的原理：

把上图菱形继承用虚拟继承实现后查看内存监视窗口

#include<iostream>
using namespace std;
class A {
public:
	int _a;
};

class B : virtual public A {
public:
	int _b;
};

class C : virtual public A {
public:
	int _c;
};
class D : public B, public C {
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针分别指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A

继承和组合

多继承由于其复杂性而被认为是C++的一个缺陷
之后的一些面向对象语言不允许多继承

在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

对象组合是类继承之外的另一种复用选择

class A{
 protected:
   int _a;
};
 
 class B{
 protected:
   int _b;
   A aa;
 };

B类的成员有A类的对象，称B组合了A

组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类的封装性

总结：

1. 类之间的关系可以用继承，也可以用组合，就用组合。
2. 有些关系适合继承那就用继承，另外要实现多态，也必须用继承。