【C++】继承（菱形继承的深入理解）

在本篇博客中，作者将会带领你深入的理解C++中的继承。

注意！！！本篇博客是在32位机器下进行讲解的，64位下会有所不同，但大同小异。

一. 继承的概念及定义

继承的概念

什么是继承？为什么要有继承？

继承是一个类继承另外一个类的所有成员，那么为什么要有继承呢？

继承是面向对象设计中提高代码复用的重要手段，它允许我们在原有类的基础上进行扩展，增加功能，这样就能产生新的类，也叫做子类 或者派生类 ，被继承的叫做父类 或者基类。

---

如下代码就是一个继承的例子：

在这个代码中，Student继承了Person所有成员，从监视窗口中也可以看到Student s1对象中有一个Person的数据，就是继承Person下来的。

继承的定义

那么继承又是如何编写的？

从上面的代码不难看出继承的编写方法：

从图中，子类和父类都很好理解，那么继承方式又是啥？

在这里，继承方式要与访问修饰符来一起看。

继承的方式一共有三种：public继承、protected继承、private继承。

那么这三种继承方式又有什么区别呢？

区别如下表所示。

举例子就是说，一个子类通过继承后，原来父类中的成员的访问权限取原本访问权限和继承方式权限****较小的那一个。

如下图所示。

总结：

1.基类的private成员，不管以什么方式的继承，在子类中都不可见，不可见的意思时，其实在子类中存在private修饰的成员，只不过我们没权限去访问它。

2.基类private修饰的成员在类外是不能访问的，被继承后在派生类中也不能访问，但是如果我们想要一个成员不能被类外访问，但是继承后能在派生类中访问，这个时候我就要使用protected来修饰成员，所以可以看出protected是为了继承才出现的。

3.使用class时默认的继承方式是private，使用struct时默认的继承方式是public。

**4.**实际中，public继承方式最常用，protected和private继承方式很少见。

二.基类和派生类中的赋值转换

派生类对象可以直接给基类的对象/指针/引用****赋值，这种行为也称作切片，

但是反过来，基类不能给派生类赋值。

切片

三.继承中的作用域

1.在继承体系中基类 和派生类 都有独立的作用域。

2.当基类和派生类中有同名的成员变量和同名的成员函数时，子类的成员将会屏蔽掉父类的成员，这种情况叫做隐藏也叫重定义，但是如果你也想在子类中访问屏蔽掉的父类成员，也可以通过 基类::成员 这种形式去访问。

3.成员函数当函数名相同时就构成隐藏。

成员变量隐藏

以下这种情况就是 成员变量构成隐藏。

#include<iostream>
using namespace std;

class Person
{
public:

	int _age = 1;
	int _num = 2;
};

class Student :public Person
{
public:

	int _num = 10;
};

int main()
{
	Person p1;
	Student s1;

	cout << s1._num << endl;//默认情况直接输出_num是子类的_num
	cout << s1.Person::_num << endl;//如果想要输出基类的_num，就要指定Person的作用域

	return 0;
}

成员函数隐藏

下面这种情况，在基类和派生类中，有同名的函数，所以构成隐藏（**注意：**不是函数重载）

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

在C++中，我们知道类是有默认成员函数的，那么在派生类中，它的默认成员函数又是怎么样的呢？下面我们来探讨一下。

构造函数

我们先来说结论：

①派生类的构造函数必须****调用基类的构造函数来完成基类成员的初始化。

②当基类没有****默认构造函数时（默认构造函数是不需要传参就能调用的构造函数），则必须在派生类的初始化列表中显式调用。

析构函数

从构造函数的部分可以看出，派生类构造时，要先去调用基类的构造，再去调用派生类的构造，那么析构函数是不是也如此？是的。

从图中，我们可以看出，当s1的生命周期结束时，会去调用~Student这个析构函数，当这个析构函数调用完成后，还会再去调用基类的析构函数。

拷贝构造

同样的，拷贝构造也是一个道理，派生类调用拷贝构造时，要先去调用****父类的拷贝构造 来完成基类成员的拷贝，再去调用****派生类的拷贝构造。

赋值=重载

同样的，赋值=重载，也是一个道理，派生类的赋值=重载要先去调用****基类的赋值=重载 ，再调用****自身的赋值=重载。

五.继承与友元

结论：友元关系不能继承，也就是说，基类的友元函数不能访问派生类的成员。

六.继承与静态成员

结论：一个在基类中定义的静态成员，被基类和派生类共享，也就是说，在所有基类和派生类对象中，它们共用一个静态成员。

七.菱形继承以及菱形虚拟继承

菱形继承是一个复杂问题，因为菱形继承会带来二义性和数据冗余的问题，所以为了解决这两个问题， 才有了菱形虚拟继承。

菱形继承

首先什么是菱形继承？在探讨菱形继承之前，我们先来看看继承有哪几种。

单继承 、多继承 、菱形继承。每次继承如下图所示。

其中，菱形继承是多继承的一种特殊形式。那么菱形继承会带来什么问题呢？我们举一个例子来看看。就如上图中的菱形继承：

我先定义一个Person类，再派生两个Student、Teacher类，再通过这两个类，派生出Assiant类。

#include<iostream>
using namespace std;

class Person
{
public:
	int _age;//年龄
};

class Student :public Person
{
public:
	int _sno;//学生学号
};

class Teacher :public Person
{
public:
	int _tno;//教师编号
};

class Assiant :public Student, public Teacher
{
public:
	int _aaa;
};

int main()
{
	Assiant a1;
	return 0;
}

此时Assiant类就是一个菱形继承的情况，那么它实例出来的对象是怎样的呢？

通过监视窗口以及画图来看，可以发现在Assiant实例出的对象中，有两份_age，这两份的_age是分别来自Student类 继承Person而来，以及Teacher类继承Person而来的。

那么菱形继承会带来什么问题呢？菱形继承会带来二义性 以及数据冗余的问题。我们继续往下看。

二义性

那么二义性到底是什么呢？这个很好理解，就是在Assiant实例的对象中，有两个_age，当我们给**_age赋值时，就会出现不知道**指的是那个_age。

如下图所示：

当我们尝试给_age赋值的时候，会报错，显示_age不明确，那是因为在a1中，有两个_age，一个是继承Student来的，一个是继承Teacher来的，那么该如何解决呢？很简单，只需要指定是那个父类的_age即可（因为Assiant是继承两个父类而来的）。

数据冗余

通过指定那个父类的成员来赋值解决了二义性的问题，但是数据冗余没有解决，一个Assiant对象里面有两个_age，但我们只需要一个即可，那么这个时候又该怎么办呢？所以这个时候需要用到虚拟继承。虚拟继承就是为了解决菱形继承问题而出现的。 现在，我们给Student和Teacher类加上虚拟继承再来看看。

#include<iostream>
using namespace std;

class Person
{
public:
	int _age;//年龄
};

class Student :virtual public Person//使用虚拟继承
{
public:
	int _sno;//学生学号
};

class Teacher :virtual public Person//使用虚拟继承
{
public:
	int _tno;//教师编号
};

class Assiant :public Student, public Teacher
{
public:
	int _aaa;
};

int main()
{
	Assiant a1;
	a1._age = 1;//数据冗余问题得到了解决，可以直接给_age赋值
	return 0;
}

通过使用虚拟继承的方式，在Assiant对象中，数据的二义性以及数据冗余的问题都得到了解决。 那么虚拟继承是如何解决菱形继承带来的问题的呢，这个时候，我们在全盘来看一下。

虚拟继承是如何解决菱形继承所带来的问题

在解释虚拟继承是如何解决菱形继承带来的问题前，我们先来看一下，普通菱形继承的底层对象模型是怎样的。 我们来使用vs的内存窗口来查看。

普通菱形继承的底层对象模型

#include<iostream>
using namespace std;

class Person
{
public:
	int _age;//年龄
};

class Student :public Person
{
public:
	int _sno;//学生学号
};

class Teacher :public Person
{
public:
	int _tno;//教师编号
};

class Assiant :public Student, public Teacher
{
public:
	int _aaa;
};

int main()
{
	Assiant a1;
	a1.Student::_age = 1;
	a1.Teacher::_age = 2;
	a1._sno = 3;
	a1._tno = 4;
	a1._aaa = 5;
	return 0;
}

通过运行上面的代码，我们通过调试和内存窗口来观察。

发现，普通菱形继承中，它的底层对象模型的布局和我们上面画的图一样。

这就是为什么普通的菱形继承会带来二义性以及数据冗余的问题。

虚拟菱形继承的底层对象模型

看完了普通继承的底层对象模型，接下来我们再来看看虚拟菱形继承的底层对象模型，看看它是如何解决二义性以及数据冗余问题的。

#include<iostream>
using namespace std;

class Person
{
public:
	int _age;//年龄
};

class Student :virtual public Person//使用虚拟继承
{
public:
	int _sno;//学生学号
};

class Teacher : virtual public Person//使用虚拟继承
{
public:
	int _tno;//教师编号
};

class Assiant :public Student, public Teacher
{
public:
	int _aaa;
};

int main()
{
	Assiant a1;
	a1._age = 1;
	a1._sno = 3;
	a1._tno = 4;
	a1._aaa = 5;
	return 0;
}

通过观察，我们发现，原来存_age的位置变到了最底下去了，而且只有一个，这样就解决了二义性的问题，这个很好理解，但是数据冗余呢？

有的同学可能会问，那么两个问号（？）的地方又存的啥，是浪费了还是怎么样了，而且这样看上去好像数据还多余了。

观察力较强的同学可能已经发现了，两个问号（？）的位置似乎是一个指针，答案也没错，两个问号（？）的地方确实是一个指针，那么这个指针是什么指针，又指向什么内容？

这两个指针叫做虚基表指针，它们各自指向一张虚基表，那么虚基表里面又是啥，我继续通过内存窗口来进行查看。

通过内存窗口我们可以看到，两个指针指向的内容中，又有一个值，分别是20和12，那么这两个20和12又有什么含义呢，观察力强的人可能会发现，20是第一个指针距离_age变量的偏移量，12是第二个指针距离_age变量的偏移量。

---

看到这里，我们基本理解了虚拟菱形继承的底层对象模型是怎样的了，也懂了虚拟继承是如何解决二义性和数据冗余的问题的。

但是可能会有同学问：不对啊，在没有使用虚拟继承时，一个对象只有五个变量，使用虚拟继承后，一个对象又六个变量，因为虽然_age少了一个，但是多了两个指针。如下图所示。

你说的没错，在这种情况下，一个对象确实变大了，但是是否造成数据冗余不能这么看，假设我们将Person类中_age换成一个数组，再通过求普通菱形继承和虚拟菱形继承的大小来看看。

我们发现，普通菱形继承的大小比虚拟菱形继承的大小大得多，那是因为对于虚拟菱形继承的底层对象模型来说，少了一个int _age[10]，只多了两个指针，所以虚拟菱形继承小的多，这个时候就体现出了虚拟菱形继承为什么能解决数据冗余的问题了。

---

当然这个时候，可能会有同学又会有问题，为什么虚基表里面要存偏移量呢？我们不能直接访问到_age成员吗？

当我们定义一个Student或者Teacher对象变量的时候，对象中的成员变量都是顺着来存储的，当我们想要访问对象的时候，也可以顺着来读而获取该值，这个很好理解，但是用了虚拟菱形继承后，Student对象和Teacher对象的_age不再是顺着来存储而是变到了最后的位置，那么如果我们想要读取Student的_age成员时，因为要顺着来读取，当我们读取到虚基表指针时，就可以通过虚基表中的偏移量来找到_age的位置，否则将会找不到。

八.总结

多继承是C++的一个缺陷之一，因为有了多继承就会有菱形继承，有了菱形继承就有了菱形虚拟继承，非常复杂，因为要解决二义性以及数据冗余的问题，但是不要慌，在实际写代码中，菱形继承是很少用的，一般来说不建议使用多继承，更不要使用菱形继承，对于菱形继承来说，理解到它的底层对象模型实现就差不多了。

继承和组合

继承大家应该都懂，那么组合又是什么，最开始我提到，继承可以提高代码的复用性，因为它允许我们在基类的基础上进行扩展。那么组合呢？我接下来举个例子来看看。

class Person
{
public:
	int _age;
};

class Student
{
public:
	Person p1;
	int _sno;
};

在最上面的继承中，为了能复用Person类，我们使用Student类去继承Person，这样就可以达到复用Person类的成员，那么其实不用继承也可以实现，我们也可以用组合来实现，如上面的代码一样，我们在Student类中组合一个Person的对象，也能达到我们的目的，那么实际写代码中，继承和组合我们应该如何选择呢？

---

1.继承是一种is-a的关系，即它表示一个类是另一个类的特殊形式，也可以说一个派生类就是一个基类，怎么理解呢？例如，上面的Person和Student中，Person是一个人，Student也是一个人，所以一般来说使用继承来实现。

2.组合是一种has-a的关系，即一个类中包含了另一个类，例如，车和轮子的关系，车中包含了轮子，所以我们在设计一个车和轮子类的时候，可在车类中组合轮子。

3.继承是一种"白箱"复用，什么是"白箱"，即它是一个透明的，内部是可见的，在子类中，父类的内部细节对于子类来说是可见的，但是继承在一定程度上破坏了封装，因为父类的protected成员在子类中是可见的，同时继承对于子类和父类来说，它们之间的关系是很强的，耦合度很高。

4.组合是一种"黑箱"复用，即在组合中，一个类对象的成员变量，对于这个组合类来说，它的内部细节是不可见的。类与类直接的关系很弱，耦合度低。

5.一般来说，优先使用组合，而不是继承，因为当组合和继承****都能用的时候，组合的复杂性对于继承来说肯定比较低，当两个都能用的时候，我们肯定是希望用最简单的。而且组合的耦合度低，代码维护性更好，而继承的耦合度高，父类的变化会影响子类，但是继承也不是说不用，正如前面所说的，继承是is-a的关系，组合是has-a的关系，我通过这两个关系来决定就好了。