C++：继承(继承的概念和性质，赋值兼容规则，菱形继承和虚拟继承)

---

1. 继承的相关概念和性质

概念：

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

性质：

• 当子类继承父类是按照public继承的，则原来父类中的public接口，在子类中还是public类型的
• 当子类继承父类是按照protected继承的，则原来父类中的public接口，在子类中就是protected类型的，子类对象就不能再直接调用，但是子类的内部是可以调用的。
• 当子类继承父类是按照private继承的，则原来父类中的public接口和protected接口，在子类中就是private类型的，子类对象就不能再直接调用，子类的内部也是不可以调用的。

用图来解释就是：

• 不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它
• 基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
• 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

这里我们必须要注意的是：

① 子类对象能直接访问到的只有父类的public成员
② 父类的private数据是永远不可能被访问的
③ 子类的内部是可以访问到父类的public成员和protected成员的
④继承属性是确保了从父类继承下来的接口在子类是什么属性，它保留的是最小的属性。(即private < protected < public)

继承体系中，static和友元关系的体现：

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。
 
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

2. 赋值兼容规则和同名隐藏

为了更好的展现继承的赋值兼容规则，我们先给出一个基类的实现

class Base
{
	public:
	//....
	private:
		int m_a_;
		int m_b_;
};

那么这个类的大小是多少呢？不难求出sizeof(Base) = 8Byte。那么当它被一个D类所继承后，D类的大小是多少呢？

class D : public Base
{
	public:
	//....
	private:
		int m_c_;
		int m_d_;
};

稍微做下验证可以发现：sizeof(D) = 16Byte，并且我们在调试的时候也可以发现，D类中是包含了基类Base的成员变量的。

那为什么会这样呢？实际上除了父类的构造函数和析构函数，其他所有的东西(包括private属性)均被子类继承了下来。

正因为这条性质，也就有了赋值兼容规则。

赋值兼容规则总共有三条：

① 子类对象可以直接初始化父类对象。
② 子类对象可以初始化父类的指针。
③ 子类对象可以初始化父类的引用。

用代码来表示就是：

Base b; //基类
D d;//派生类
b = d; 
Base* pb = &d;
Base& rb = d;

它的赋值其实就相当于取了子类的切片，如图：

但是我们要注意的是，虽然又可能是将子类对象的地址赋值给了父类指针，因此父类指针现在是指向子类对象的，但是父类指针只能访问到属于父类的成员变量和成员函数，是访问不到子类的成员的。

并且，子类对象在进行初始化的时候，必须先调用父类的构造方法，然后再执行子类的构造方法。

同名隐藏

首先我们需要知道的是，在继承体系中基类和派生类都有其独自的作用域。

只要子类中拥有和父类相同的函数名的方法，(注意只要是函数名相同)，则父类的同名函数均会在子类中被隐藏起来。子类对象就不能直接访问父类的同名函数，但是可以使用 (基类::基类成员 显示访问)，这种情况就是同名隐藏。

需要注意的是：只要函数名相同，那就会被隐藏，不管参数是否一样

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

众所周知，一个类有6种默认的成员函数，分别是：构造、拷贝、析构、赋值重载、取地址重载(分为const的和非const的)，那么在继承体系中，它们又是如何体现的呢？

• 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
• 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
• 派生类的operator=必须要调用基类的operator=完成基类的复制。
• 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
• 派生类对象初始化先调用基类构造再调派生类构造。
• 派生类对象析构清理先调用派生类析构再调基类的析构。

用图来表示就是这样：

4. 菱形继承和菱形虚拟继承

在说菱形继承之前，我们首先来看看多继承。所谓多继承就是一个子类有两个或以上直接父类时称这个继承关系。

多继承中子类的构造函数的构造顺序是受到继承顺序所影响的，与主动调用的顺序是无关的。

那么菱形继承就是多继承的一种特殊情况。

菱形继承也会带来许多问题，菱形继承有数据冗余和二义性的问题，如下图：

当程序想要取调用m_a_的时候，不知道该访问哪个，这就造成了程序的二义性问题。并且在D中m_a_有两份，造成了空间浪费。

那么该如何解决这个问题呢？

采用虚拟继承即可解决此问题，即为菱形虚拟继承。（加上virtual关键字即为虚拟继承）。

为了验证虚拟继承是否真的可以解决此类问题，我们写份代码来测试一下。

首先我们先来验证一下，菱形继承所存在的问题。

class A
{
public:
	//...
private:
	int m_a_;
};

class B : public A
{
public:
	//...
private:
	int m_b_;
};

class C : public A
{
public:
	//...
private:
	int m_c_;
};

class D : public B,public C
{
public:
	//...
private:
	int m_d_;
};

在调试的窗口可以看到，D类实例化出的对象d，它拥有两个m_a_，造成了空间的浪费和二义性。

接下来，我们加上虚拟继承，先来看看现象。

class A
{
public:
	//...
private:
	int m_a_ = 1;
};

class B : virtual public A
{
public:
	//...
private:
	int m_b_ = 2;
};

class C : virtual public A
{
public:
	//...
private:
	int m_c_ = 3;
};

class D : public B,public C
{
public:
	//...
private:
	int m_d_ = 4;
};

我们观察到的是m_a_的数量不但没有减少，反而是增加了一个类A，那这是为什么呢？

这就牵扯到了虚拟继承的原理，下面我们借助内存窗口来对其进行分析。

当我们观察d的内存的时候，发现本应该是m_a_的地方变成了一个地址，即B中的m_a_部分被地址代替，C中的m_a_被地址代替，那么我们再来看看这些地址到底存储了什么？


不难发现，这些地址所指向的值，代表了从当前位置找到m_a_的偏移量。

这些地址中其实均指向了一张表，这两个指针叫做虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到上面的A。

用图来解释就是：

5. 组合和继承

• public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
• 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
• 优先使用对象组合，而不是类继承 。
• 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
• 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
• 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。