C++中的继承问题(继承基本概念、菱形虚拟继承的对象模型)

目录

• 一、继承的概念与定义格式
• 概念及定义格式
• 二、赋值兼容规则
• 三、继承中的作用域
• 四、子类的默认成员函数
• 构造函数
• 拷贝构造函数
• 赋值运算符重载
• 析构函数
• 构造和析构函数调用顺序
• 五、继承与友元、静态成员
• 友元关系
• 静态成员
• 六、菱形继承及菱形虚拟继承
• 菱形继承概念
• 存在问题
• 虚拟继承的概念
• 虚拟继承的模型
• 总结

一、继承的概念与定义格式

概念及定义格式

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

个人理解：父类实际上是抽取类的共性，将其它类都有的属性和方法进行提取，再定义其它类时只需要继承父类，并写出该类独有的属性即可。

以Person类为父类，Student类为学生类举例：

父类

子类

这里Student类继承了Person类，学生中就包含Person类中的name和age两个属性，只需要再写出Student类独有的num属性即可。

访问限定符与继承权限

一句话总结上面的表格：继承权限决定了子类能继承的父类的最高权限。即public继承不会改变类成员的访问权限；protected继承方式会改变原来访问权限为public的成员；private继承方式会影响原来访问权限为public和protected的成员。

另外还有几点要注意：

父类的private成员被子类继承了，但是子类不能访问父类的private成员，通过查看子类的大小可以得知，子类中包含继承自父类的私有成员变量。

在子类中访问父类私有成员会报错：

查看子类大小：

• protected成员访问限定符只因为继承体系才出现的，因为protected在继承中才有意义
• 实际中一般使用public继承
• 使用关键字class默认的继承方式是private，使用struct默认的继承方式是public，一般最好显式给出继承权限。

ps： class和struct的区别

• 定义类的默认访问权限不同，class为私有，struct为公有，兼容C语言
• 模板参数列表中可以使用class，不能使用struct
• 继承中的默认继承权限不同，class默认private，struct默认public

二、赋值兼容规则

这里的复制兼容规则是在public继承的前提下：

• 可以使用子类对象给父类对象赋值赋值，但是不能使用父类对象给子类对象赋值
• 可以使用父类指针指向子类对象，但不能使用子类指针指向父类对象，如果一定要指向，进行强制类型转换后可以，但是会有指针越界访问的问题。
• 可以使用父类的引用去引用子类，不能使用子类的引用引用父类，与指针原理相同。

仍以 Person类和Student类举例：

Person类：

lass Person
{
protected:
	string _name;
	int _age ;
};

Student类继承Person类：

class Student :public Person
{
protected:
	int _num = 1;
};

分别验证赋值、指针和引用：

原理如图：

指针和引用原理与上图相同，父类的指针可以指向子类中继承自父类的部分；但是子类的指针如果指向父类，访问_name和_age时不会有问题，访问到_num时就会超出父类对象的范围，越界访问，所以编译器禁止了子类指针指向父类对象。

三、继承中的作用域

• 在继承体系中，父类和子类都有独立的作用域
• 如果父类和子类中有同名成员，子类成员会屏蔽对父类同名成员的直接访问，优先访问自己类中的成员，即同名隐藏，也叫重定义。
• 对于成员函数，只要函数名相同就构成重定义，与类型无关。

Person类：

class Person
{
public:
	void Print()
	{
		cout << "Person name:" << _name << endl;
		cout << "Person age" << _age << endl;
	}
protected:
	string _name = "ZS";
	int _age = 17;
};

Student类继承Person类：

class Student :public Person
{
public:
	void Print()
	{
		cout << "Student name：" << _name << endl;
		cout << "Student age：" << _age << endl;
		cout << "Student num：" << js_num << endl;
	}
protected:
	string _name = "LS";
	int _age = 18;
	int _num = 2;
};

验证结果：

当不加作用域限定符时，子类对象会优先访问自己的成员变量和成员函数。

对程序稍作修改：

这里两个Print函数的参数不同，看起来像“重载”，但是实际上是同名隐藏，子类中对父类的Print函数进行了重定义。

四、子类的默认成员函数

构造函数

父类 没有显式定义构造函数 或者父类有 全缺省的构造函数 或者 无参的构造函数 ，子类可以不定义构造函数。

即下面三种情况，子类都可以不显式地给出构造函数：

但是如果父类显式定义了构造函数，且不是无参或者全缺省的，子类必须显式定义构造函数，并在初始化列表显式调用父类的构造函数，因为如果不显式定义，编译器会自动调用父类默认拷贝构造函数，而父类没有默认的构造函数，便会报错：

正确的写法：

这里的name是传递给Person类构造函数的实参，即：用name给Student对象中继承的_name赋值。

构造一个Student类的对象分两步：

• 将从父类继承的成员初始化
• 将子类新增加的成员初始化

拷贝构造函数

子类的拷贝构造函数必须在初始化列表中显式调用父类的拷贝构造函数。

父类没有定义拷贝构造函数，子类可以定义也可以不定义；父类如果定义了拷贝构造函数，子类一般要定义，并且要在初始化列表中调用父类的拷贝构造函数完成从父类继承的成员的拷贝初始化，否则会报错：

正确写法：

此处s是传递给拷贝构造函数的参数。

赋值运算符重载

子类的赋值运算符重载函数必须调用父类的赋值运算符重载完成对父类的赋值。

父类的赋值运算符重载：

子类：

析构函数

子类析构函数会在被调用完后自动调用父类的析构函数完成清理父类成员，所以清理顺序是：先清理子类，再清理父类。

构造和析构函数调用顺序

构造子类对象时，先调用父类的构造函数，再调用子类的构造函数，清理对象时，先调用子类的析构函数，再调用父类的析构函数。

如图：

因为构造子类对象时会在初始化列表中调用父类的构造函数，执行完之后才会执行子类的构造函数的函数体，所以父类的构造会先于子类的构造执行。

五、继承与友元、静态成员

友元关系

友元关系不能继承

tips：王叔是你父亲的好朋友，但是不一定是你的好朋友，王叔的财产不会 给你继承

定义一个Display函数，并在Person类中声明为友javascript元类：

在Display函数中可以访问Person类的protected成员，但是不能访问其子类Student类成员，友元关系不能继承。

静态成员

父类中声明了static静态成员，则整个继承体系只有一个这样的成员。无论派生出多少子类，都只有一个static成员实例。

定义A、B、C三个类：

class A
{
protected:
	int _a;
public:
	static int _count;//类中声明为静态成员
};

int A::_count = 0;//类外定义

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

class C :public B
{
protected:
	int _c;
};

通过不同对象访问_count：

六、菱形继承及菱形虚拟继承

菱形继承概念

单继承

多继承

菱形继承

可以看出，菱形继承实际就是单继承和多继承组合js的结果，是多继承的一种特殊情况。

菱形继承实例：

注：验证环境为VS2022，win32平台

这里C类的大小是20字节，除了其本身成员的4字节，另外16个字节都是从两个父类继承来的。模型如图：

存在问题

对于上面图中的菱形继承，存在的问题十分明显，那就是数据冗余和二义性问题。即Teacher类和Student类都继承自Person类，那么两个类中都会包含Person类中的成员，Assistant继承这两个类之后，同样的成员便会包含两份，导致数据重复，并且在通过Assistant对象访问Person类中的成员时，会有二义性。

通过添加作用域限定符可以解决访问二义性的问题，如：as.Teacher::_name类似的语句可以指定通过哪个父类访问Person类的对象，但是无法从根本解决数据冗余的问题，所以便引入了虚拟继承的概念。

虚拟继承的概念

虚拟继承是指在继承权限前面加上一个virtura关键字

class B1:virtual public A
{
public:
	int _b1;
};

用虚拟继承可以解决菱形继承的二义性和数据冗余的问题。对于上面的菱形继承，在B1和B2继承A时使用虚拟继承即可解决问题。

虚拟继承的模型

对于上面的菱形虚拟继承，研究其模型。

通过sizeof打印输出获取c对象的大小为24字节：

通过下面的语句为c对象中js的成员赋值：

void Test()
{
	C c;
	c._a = 1;
	c._b1 = 2;
	c._b2 = 3;
	c._c = 4;

	cout << sizeof(c) << endl;
}

查看其内存分布

所以，菱形虚拟继承将最上面的父类中的成员只保存了一份，并用一个偏移量指针指向偏移量表格，偏移量表格中保存的就是最上面的父类中的成员变量相对于当前对象的偏移量。

最终得到的菱形虚拟继承对象内存模型如图：

对象模型与偏移量表格：

开发者_JAVA教程

总结：假设B1和B2继承自A类，最下面的C类继承自B1和B2类；菱形虚拟继承是指两个子类继承自同一个父类时，将继承方式设置为虚拟继承；构建对象时，最顶层的父类A中的成员变量只保存一份，在对象模型的最下面，这样就避免了数据冗余；B1和B2都有属于自己的虚基表指针，通过虚基表中的偏移量找到最顶层父类中的_a成员变量；

B1和B1类中都有自己的虚表，这样便可以通过C类对象给B1类和javascript者B2类的指针、引用或者对象赋值，满足赋值兼容规则

附录：

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。