全网最全的c++继承包含了菱形继承，虚拟继承，虚基表等内容

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量57 收藏
点赞数 2
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72433000/article/details/132433411
版权 
所谓无底深渊，下去，也是前程万里。

文章目录

1.继承的概念及定义

1.1继承的概念

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

class A {
public:
	A() {
		cout << "A" << endl;
	}
	int a;
};
class B : public A{
public:
	B() {
		cout << "B" << endl;
	}
	int b;
};

1.2继承的定义

在这里插入图片描述

1.3继承关系和访问限定符

上面呢我们可以看到B是子类也叫派生类，A是父类也叫基类，public是继承方式。
那么有public继承方式肯定也有别的继承方式喽，没错也有别的继承方式，并且是有组合的，组合的结果呢就是下面那张图片。
在这里插入图片描述

1.4继承基类方式访问成员的变化

在这里插入图片描述

1.5总结

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

2.基类和派生类的赋值转换

  1. 基类对象可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法寓意是值将父类的那一部分切割过去。

  2. 基类对象不能赋值给派生类对象。

  3. 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类时才是安全的。这里基类如果是多态类型，可以使用RTTI的dynamic cast来进行识别后进行安全转换

     可以看一下下面这个代码。比较全面的说明类赋值转换。

#include<iostream>
using namespace std;
class person {
public:
	person()
	{
		cout << "person" << endl;
	}
};
class studen :public person 
{
public:
	studen()
	{
		cout << "studen" << endl;
	}
};
int main()
{
	studen f;
	person son;
//	父类的指针和派生类的指针
	studen*s=&f;
	person* pf = &son;
//	派生类的地址可以赋值给父类的指针
	pf = &f;
//	父类的地址不可以赋值给派生类的指针
	s = &son;//这里在编译器中会报错
	return 0;
}

3.继承中的作用域

  1. 在继承的体系中派生类和基类都有自己独立的作用域。
  2. 子类和父类中有同名成员，子类成语将屏蔽父类对同名成员的直接访问，这种情况叫隐藏也叫重定义。（在子类成员函数中可以使用基类：：基类成员显示访问）
  3. 这里要注意如果是成员函数的隐藏的话只需要成员函数同名就可以了。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。
#include<iostream>
using namespace std;
class person {
public:
	int _num = 111;
	string name = "张三";
	void print()
	{
		cout << _num << ":_num" << endl;
		cout << name << ":name" << endl;
	}
};
class studen :public person 
{
public:
	int _num = 999;
	string name = "李四";
	void print(int val = 10)
	{
		cout << _num << ":_num" << endl;
		cout << name << ":name" << endl;
	}
};
int main()
{
	studen f;
	person son;
	f.print();
	return 0;
}

上面的这个列子大家可以看一下，我们可以看出来即使派生类和基类的成员函数的类型并没有保持一只但是在调用的时候仍然是调用的派生类的print函数。

4.派生类的默认构造函数

6个默认构造函数，默认的意思就是我们不写但是编译器会自动生成一个，这几个函数主要又以下几个。

  1. 派生类的构造函数必须调用基类的构造函数从而初始化基类的成员。如果基类没有默认的构造函数那必须在派生类的显示列表中显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造从而完成基类拷贝的初始化
  3. 派生类的operator=必须调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员因为这样才能保证派生类对象先清理派生类对象在清理基类成员的顺序。
  5. 派生类的初始化先调用基类的构造函数再调用基类的构造。
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
  7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个大家有兴趣可以接下来看一下我的另一个文章 多态)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加\virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

5.继承和友元

这里的话其实大家记住一句话就可以了那就是友元关系不可以继承，这里的话其实很好理解，那就是你爸爸的朋友他不一定就是你的朋友。换句话也就是基类的友元函数不能访问派生类的保护和私有成员。

6.继承和静态成员

基类定义了一个static 成员那么无论继承了多少次在这整个继承体系中只有一个这样的成员。无论派生了多少次都只有一个static实列。我们可以通过一下代码进行证明。

#include<iostream>
using namespace std;
class person {
public:
	 static int cot;
	int _num = 111;
	string name = "张三";
	void print()
	{
		cout << _num << ":_num" << endl;
		cout << name << ":name" << endl;
	}
};
int person::cot = 0;
class studen :public person 
{
public:
	int _num = 999;
	string name = "李四";
	void print(int val = 10)
	{
		cout << _num << ":_num" << endl;
		cout << name << ":name" << endl;
	}
};
class studen2 :public person {
public:
	int _num = 999;
	string name = "王五";
};
int main()
{
	studen son;
	person f;
	studen2 stu;
	stu.cot++;
	cout << f.cot << endl;
	son.cot++;
	cout << f.cot << endl;
	return 0;
}

在这里插入图片描述
上面我们可以看到无论是从派生类1或者派生类2对cot变量进行修改最终都会影响到cot本身当然了也可以直接从地址上进行更加直观的观察。

7.复杂的菱形继承及菱形虚拟继承（本节重点）

在开启菱形继承前我们首先要知道两个概念分别是单继承和多继承。

7.1单继承

一个子类只有一个父类时这个继承关系成为单继承如下图

在这里插入图片描述

7.2多继承

多继承指的就是一个子类拥有不止一个父类。如下图

在这里插入图片描述
好的那么我们知道了单继承和多继承之后呢我们可以发现多继承的这种形式就会出现一个特殊的情况，那就是菱形继承。

7.3菱形继承

通过上面的说明我们可以知道菱形继承其实就是多继承的一种特殊形式那么用图的形式表示出来是什么样子呢请看下图。
在这里插入图片描述
就是这样子，可能有人会疑惑这样子有什么危害呢？我们可以试着画一下如果发生这种继承的话那么Assistant这个类对象的内部会保存哪些组成呢？
在这里插入图片描述
请看上图根据我们的菱形继承，Assistant类实列化出来的对象会保存的有这些值，这里面主要有Assistant自己本身的成员，以及student的成员，以及teacher的成员，那么这里我们会发现，student和teacher这两个成员中有一个值相同但是地址不同的地方那就是person。
那么我们可以这样理解假如说Assistant是一个人，他的名字保存在person中我们访问person可以从student访问也可以从teacher访问，也就是说这个人有两个名字，他作为teacher时使用的是一个名字，他作为student时却是一个名字，那么这样子同学们可能感觉很合理啊，我作为老师大家可以叫我陈老师，张老师，作为学生可以叫我陈同学，张同学。可是在这跟取别名不一样的地方再与取别名是我任何时候都可以这样子代表你就好比你小名叫皮蛋那么在抛开礼节的情况下，我可以在家里叫你，在学校叫你，你成为老师后我依然可以叫你，但是这里可以吗？显然不可以因为这里的person是单独存在于student以及teacher中的也就是说就好比，你是学生的时候我叫你陈同学，但是当你变成老师的时候我再叫你陈同学我就不是再叫你了这显然很不合理。

	我给大家写一个代码帮助大家的理解	

class Person
{
public :
 string _name ; // 姓名
};
class Student : public Person
{
protected :
 int _num ; //学号
};
class Teacher : public Person
{
protected :
 int _id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected :
 string _majorCourse ; // 主修课程
};
void Test ()
{
 // 这样会有二义性无法明确知道访问的是哪一个
 Assistant a ;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
 a.Student::_name = "xxx";
 a.Teacher::_name = "yyy";
}

7.3.1菱形继承的缺点

从上面我们的描述中呢我们发现了菱形继承可以说是弊大于利的，那么菱形继承的缺点我们总结起来其实就是，会导致，数据冗余，以及二义性。
而在java中呢就没有菱形继承这个东西因为它就没有多继承，其实这也是java抄c++作业一个很不错的地方为什么c++被很多人吐槽难学其实也正是这个原因因为它有太多的就是站在当时那个角度没有考虑进去的问题了。

7.3.2如何改进菱形继承（虚拟继承）

那么正是因为菱形继承我们如果对c++的迭代有些了解的同学呢就会发现在之后的两个版本中祖师爷可以说想尽了办法去修补菱形继承这个缺点，最终呢解决办法就是引进了虚拟继承。

	那么什么是虚拟继承呢？
	虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和
Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地	
方去使用。

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

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成
员的模型。
首先呢下面这张图是没有进行虚拟继承的样子那么虚拟继承其实就是将腰部 的继承关系加一个virtual代码我给大家粘贴一下

//未进行虚拟继承的代码
#include<iostream>
using namespace std;
class A {
public:
	int _a=1;
};
class B :public A {
public:
	int _b=2;
};
class C :public A {
public:
	int _c=3;
};
class D :public B, public C {
public:
	int _d=4;
};
int main()
{
	D d;
	A a;
	B b;
	C c;
	return 0;
}



//虚拟继承的代码如下
#include<iostream>
using namespace std;
class A {
public:
	int _a=1;
};
class B :virtual public A {
public:
	int _b=2;
};
class C :virtual public A {
public:
	int _c=3;
};
class D :public B, public C {
public:
	int _d=4;
};
int main()
{
	D d;
	A a;
	B b;
	C c;
	return 0;
}

未进行虚拟继承的图片如下

在这里插入图片描述

接下来是进行虚拟继承的图如下

在这里插入图片描述

上面两张图片我们可以看一下区别首先呢我们发现原来保存A的地方保存成了一个地址，而A呢则出现了最底部那么我们可以看一下原来保存A的地方保存的东西是什么。
在这里插入图片描述
在这里插入图片描述
采用内存窗口查看的时候我们发现这里面存的是一个整数。
那么这个整数有什么意义呢？其实这个整数就是B和C距离A的地址的偏移量，这里其实就是两个指针当我们需要读取A的时候指针先读取到偏移量，然后呢根据偏移量找到A的地址从而访问A那么这里。而存储偏移量的这个表就被称为虚基表

7.3.4虚基表

首先什么是虚基表

通过我们上面的描述虚基表存储的是腰部派生类到达基类的偏移量，通过偏移量来找到基类的地址从而实现我们可以找到访问基类，从而只保存一个基类的同时又可以让B和C访问到基类（A）。

好的那么还有一个问题就是为什么要这样做

为了搞清楚这个问题我们要先知道虚基表是干什么的，通过上面我们可以知道虚基表是为了存储偏移量的。

为什么要存储偏移量呢？ 因为为了找到基类的地址从而可以访问基类。

那么为什么我们不直接存储基类的地址，而是先存储偏移量的地址，再读取偏移量呢？ 那么这个问题其实是因为我们太局限了，我们要明白一个问题，这个继承体系中有多少个菱形继承？很明显只有一个那么我们以后还会遇到不止一个菱形继承比如说。下图这个样子
在这里插入图片描述
如果说我们选择了存储基类的地址的话那么图中我们需要存储多少个基类的地址呢？很明显是两个一个是A 一个是E而如果我们采取虚基表的方式的话我们只需要存储一个偏移量的地址，然后通过偏移量依次读取B和C的偏移量直接算出来即可。这样的话不就节省了更多的空间了吗？

虚基表的好处

虚基表有什么好处呢？首先肯定是解决了菱形继承的导致的数据冗余和二义性的问题。那么还有一个好处就是我们提到的切片操作，在切片的时候我们需要偏移量来保证我们切的准确，因此这里的话可以直接访问虚基表就可以了。

关于继承的总结

  1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱
    形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设
    计出菱形继承。否则在复杂度及性能上都有问题。
  2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
  3. 我们在使用的时候优先使用组合，其次使用继承。
Achlorine
关注
专栏目录
8-5：C++继承之多继承，菱形继承，虚继承，虚基表，继承和组合
快乐江湖的博客
05-05 455
文章目录一：对继承的理解二：继承的定义（1）定义格式（2）继承方式和访问限定符三：父类和子类对象赋值转换 一：对继承的理解 面向对象三大特性：封装，继承和多态。其中封装是指将数据和方法整合在一起，并加以作用域限制符进行限定，以达到更好的管理数据的目的，那么继承又应该如何理解呢 在实现一个教务系统时，对于人员大部分都会分为学生，教师这两种，那也就意味着要创建两个个对应的类，学生会有自己的姓名，年龄和学号以及以及拥有查看教务系统和做作业的行为，教师也会有自己的姓名，年龄和工号以及拥有查看教务系统和布置作业的行为
C++中的菱形继承问题详解
weixin_48716357的博客
09-08 5492
不难发现，在菱形继承中也存在二义性，并且出现数据冗余浪费了内存空间，由基类Person的_idPerson身份证号有两条路径继承到EGStudent类中，两个身份证号在逻辑上是相同的，但在物理上被分配了不同的内存空间，是两个变量。有了多继承，就有菱形继承，有了菱形继承就有了菱形虚拟继承，底层实现很复杂，一般不建议设计出多继承，否则在复杂度和性能上可能都会出现问题。由多个基类共同派生出新的派生类出新的类，这样的继承结构被称为多重继承或多继承。而在多继承中还存在一种特殊情况——菱形继承。
【C++】解决菱形继承而产生的虚基表（偏移量表）
Front123456的博客
07-27 277
菱形继承对象模型，菱形虚拟继承对象模型，虚基表分析，为什么存偏移量而不直接存地址？
C++多继承，菱形继承，虚继承 ，虚基表和虚基表指针
Misszhoudandan的博客
05-04 1303
多继承 当一个子类只有一个直接父类时，称这个继承关系为单继承 当一个子类有两个或两个以上的直接父类时，称这个继承关系为多继承 当存在多继承时，就有可能形成这样一种继承关系 我们称上面的继承关系为菱形继承，来看看菱形继承如何实现   class Person { public:  Person(const string name = "") :_name(name)   {...
C++继承详解三 ----菱形继承、虚继承
丁香枝上，豆蔻梢头
04-17 1032
今天呢，我们来讲讲菱形继承与虚继承。这两者的讲解是分不开的，要想深入了解菱形继承，你是绕不开虚函数这一点的。它俩有着什么关系呢？值得我们来剖析。 菱形继承也叫钻石继承，它是多继承的一种特殊实例吧，它的基本架构如下图： 在我们的设想中，D所对应的对象模型应该如下图所示： 下面我们来用一段代码验证一下： class A { public: A() { cout
C++菱形继承与虚继承
随便记点东西
08-14 2722
虚继承，菱形继承
面向对象C++用虚继承来消灭菱形结构二义性,解决俩爷爷的问题.zip
01-22
总结来说，C++中的虚继承是一种解决多继承菱形结构问题的策略，它通过确保共享基类的单一实例来消除二义性。理解虚继承的原理和使用场景对于编写清晰、无冲突的面向对象代码至关重要。通过阅读《C++通过虚继承来消灭...
C++|虚继承解决菱形继承的问题
X_ar_的博客
03-09 654
前言 菱形继承：两个子类继承同一个父类，又有子类同时继承这两个子类。 如图所示，子类Subclass1和Subclass1继承同一个父类BaseClass，SubclassA同时继承上述两个子类。 菱形继承问题 1、Subclass1继承了BaseClass的数据，Subclass2同样继承了BaseClass的数据，当SubclassA使用数据时，就会产生二义性。 解释：现附上此案例代码进行分析： #include <iostream> using namespace std; class
C++（第十一篇）：继承（基类与派生类、菱形继承和菱形虚拟继承问题）
杨同学的博客
12-11 1089
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类去继承一个已有的类即可。这个已有的类称为基类（父类），新建的类称为派生类（子类）。很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出菱形继承。否则在复杂度及性能上都有问题。
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 120
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 474
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 1065
💫往期文章👇：
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 885
set、map仿STL模拟实现
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 444
继续学习头文件的数学函数。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 738
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【C++ && Qt day11】
wzj46的博客
09-11 259
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1037
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 441
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
c++继承多态虚基表
07-29
C++中的继承和多态是面向对象编程的重要特性之一。在C++中，虚函数和虚基类是实现多态的关键。 首先，让我们来了解一下继承的概念。继承是一种从已有类创建新类的机制，其中新类可以继承已有类的属性和方法。在C++中，通过使用关键字`class`来进行继承。 接下来，我们来讨论一下多态。多态是指同一种操作可以根据对象类型的不同而具有不同的行为。在C++中，使用虚函数来实现多态。虚函数是在基类中声明的一个函数，它可以在派生类中被重写。通过使用`virtual`关键字，可以告诉编译器在运行时选择正确的函数调用。 当涉及到多重继承时，可能会出现虚基类的概念。虚基类是用于解决多重继承中的问题，例如菱形继承问题。通过使用`virtual`关键字来声明虚基类，可以确保在继承体系中只有一个共享的基类实例。 多态和虚函数的机制是通过使用虚函数表（vtable）来实现的。每个包含虚函数的类都会有一个对应的虚函数表，其中存储了指向实际函数的指针。当调用一个虚函数时，实际执行的是虚函数表中指向正确函数的指针。 希望这能解答你关于C++继承多态和虚基表的问题。如果有其他问题，请随时提问！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值