继承(下) (Inheritance)

念恒123062026-04-11 5:08

目录

1.继承与友元

2.继承与静态成员

3.多继承及其菱形继承问题

[3.1 继承模型](#3.1 继承模型)

3.2虚继承

[3.3 IO库里面的菱形虚拟继承](#3.3 IO库里面的菱形虚拟继承)

3.4一些细节以及问题

多继承中指针偏移问题：

[1.下面说法正确的是( )](#1.下面说法正确的是( ))

[2.下面说法正确的是( )](#2.下面说法正确的是( ))

4.继承和组合

4.1继承和组合

继继承(上)，我们继续对继承进行学习！

1.继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员 。

cpp 复制代码 
#include<iostream>
using namespace std;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}

int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

如果这样写会发现编不过，其中报错

其实是因为friend函数里面有子类的，但是把子类放到父类前面又不对，这样就不会是继承，因此需要给前置声明才行。

cpp 复制代码 
//前置声明
class Student;

还有报错

因为Display是Person的友元，而Display里又要访问Student的学号(_stuNum)，即便Student继承Person。从这也能看出友元关系不能被继承。

解决办法：把Display也变成Student的友元

最终代码

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//前置声明
class Student;
class Person
{
public:
	//友元关系不能被继承
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

class Student : public Person
{
	friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}

int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

2.继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都 只有一个static成员实例。

正常继承是，父类有个_name，子类有个_name，但是两个_name不是一个_name。

而静态成员不同，它是同一个，传家宝。

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	// 这里的运行结果可以看到非静态成员_name的地址是不一样的
	// 说明派生类继承下来了，父派生类对象各有一份
	cout << &p._name << endl;
	cout << &s._name << endl;
	// 这里的运行结果可以看到静态成员_count的地址是一样的
	// 说明派生类和基类共用同一份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;
	// 公有的情况下，父派生类指定类域都可以访问静态成员
	cout << Person::_count << endl;
	cout << Student::_count << endl;
	return 0;
}

这里的运行结果可以看到非静态成员_name的地址是不一样的
说明派生类继承下来了，父派生类对象各有一份

这里的运行结果可以看到静态成员_count的地址是一样的
说明派生类和基类共用同一份静态成员

公有的情况下，派生类和基类指定类域都可以访问静态成员

3.多继承及其菱形继承问题

3.1 继承模型

单继承：一个派生类只有一个直接基类时称这个继承关系为单继承

多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面。

下图左边单继承，右边多继承

菱形继承：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议 设计出菱形继承这样的模型的。

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

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; // 主修课程
};

int main()
{
	Assistant a;
	a._name = "peter";
	return 0;
}

  • Student 和 Teacher 各自包含一份 Person 的子对象。

  • Assistant 会包含两份 Person 的子对象（一份来自 Student，一份来自 Teacher）。

  • 当你写 a._name 时，编译器不知道你要访问哪一份（来自 Student 的还是来自 Teacher 的），因此报错二义性。

其中一个解决方案，显示指定访问哪个基类的成员可以解决二义性问题，但是数据冗余问题无法解决(会造成浪费)。

cpp 复制代码 
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";

完整代码

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

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; // 主修课程
};

int main()
{
	Assistant a;
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

库里面设计一个既想有ostream又有istream的特征，由此设计了iostream。这就是经典的菱形继承。但是其实C++引入了一个虚继承来解决二义性等问题。

3.2虚继承

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之一，后来的一些编程语言都没有多继承，如Java。

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Person
{
public:
	string _name; // 姓名
};

class Student : virtual public Person
{
protected:
	int _num; //学号
};

class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	Assistant a;
	a._name = "peter";
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

  • Student 和 Teacher 对 Person 采用虚继承，意味着它们共享同一个 Person 子对象。

  • Assistant 中只有一份 Person 子对象。

  • 因此 a._name 直接访问这一份，没有歧义。

  • 同时 a.Student::_name 和 a.Teacher::_name 也是访问同一份数据（所以后两句会覆盖前一句的值，但不会报错）。

如果上面只加一个虚继承，这样是不行的。

3.3 IO库里面的菱形虚拟继承

cpp 复制代码 
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{};

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{};

3.4一些细节以及问题

谁会产生数据冗余和二义性就在继承他的地方

A有数据冗余和二义性，所以在B、C加

哪个类(公共基类)产生了数据冗余和二义性，继承时用虚继承

多继承中指针偏移问题：

1.下面说法正确的是( )

A：p1 == p2 == p3 B：p1 < p2 < p3

C：p1 == p3 != p2 D：p1 != p2 != p3

cpp 复制代码 
class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

答案C

  • p1 和 p3 的值相等 （都指向 Derive 对象的起始地址，因为 Base1 是第一个基类）。

  • p2 的值与 p1、p3 不同 （Base2 子对象位于 Derive 对象中的偏移位置）。

  • p1 == p3 为 true ，p2 != p1 为 true。

  • 任何基类指针都可以安全地指向派生类对象，但地址可能不同。

2.下面说法正确的是( )

A：p1 == p2 == p3 B：p1 < p2 < p3 E：p1 != p2 == p3

C：p1 == p3 != p2 D：p1 != p2 != p3

答案E

  • Base2* p2 = &d; 指向 d 的起始地址。

  • Derive* p3 = &d; 也指向 d 的起始地址。

  • Base1* p1 = &d; 指向 Base1 子对象的地址，即起始地址偏移 sizeof(Base2) 字节。

所以 p2 == p3 为真 ，而 p1 与它们不同。

4.继承和组合

4.1继承和组合

1.public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

2.组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

3.继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用 (white-box reuse)。术语"白箱"是相对可视性而言：在继承方式中，基类的内部细节对派生类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依 赖关系很强，耦合度高。

4.对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)， 因为对象的内部细节是不可见的。对象只以"黑箱"的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

5.优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。

黑盒测试 不需要了解底层实现,从功能角度测试
白盒测试->难 了解底层实现,从代码运行逻辑角度测试

高内聚，低耦合

我们继承的学习就到此结束，期待我们下次再见！！！

相关推荐
H Journey3 小时前
C++之 CMake、CMakeLists.txt、Makefile
开发语言·c++·makefile·cmake
研究点啥好呢7 小时前
Github热门项目推荐 | 创建你的像素风格！
c++·python·node.js·github·开源软件
_dindong7 小时前
cf1091div2 C.Grid Covering（数论）
c++·算法
沫璃染墨7 小时前
C++ string 从入门到精通：构造、迭代器、容量接口全解析
c语言·开发语言·c++
6Hzlia8 小时前
【Hot 100 刷题计划】 LeetCode 17. 电话号码的字母组合 | C++ 回溯算法经典模板
c++·算法·leetcode
计算机安禾8 小时前
【数据结构与算法】第36篇：排序大总结：稳定性、时间复杂度与适用场景
c语言·数据结构·c++·算法·链表·线性回归·visual studio
unicrom_深圳市由你创科技8 小时前
做虚拟示波器这种实时波形显示的上位机，用什么语言？
c++·python·c#
无限进步_9 小时前
【C++】电话号码的字母组合：从有限处理到通用解法
开发语言·c++·ide·windows·git·github·visual studio
C++ 老炮儿的技术栈9 小时前
GCC编译时无法向/tmp 目录写入临时汇编文件，因为设备空间不足，解决
linux·运维·开发语言·汇编·c++·git·qt
热门推荐
01GitHub 镜像站点02一周AI热点速览（2026.03.31-04.06）：GPT-6曝光、谷歌开源Gemma 4、资本狂飙与模型军备竞赛03OpenClaw 请求超时 llm request timed out 怎么解决？3 种方案实测，附完整排查流程04AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南05MySQL表约束详解：8大核心约束实战指南06实测！Gemma 4 成功跑在安卓手机上：离线 AI 助手终于来了07Oh My Codex 快速使用指南08CodeBuddy与WorkBuddy深度对比：腾讯两款AI工具差异及实操指南09VMware Workstation Pro 17 虚拟机完整安装教程（2026最新）10UV安装并设置国内源