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

虚拟笔记使

已于 2024-05-17 00:13:06 修改

阅读量983

点赞数 12

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-05-12 22:24:07 首次发布

本文链接：https://blog.csdn.net/EWIAW_ilove/article/details/138549381

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

在本篇博客中，作者将会带领你深入的理解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的关系，我通过这两个关系来决定就好了。