学 C++ 继承看这篇！派生类函数实现 + 虚继承原理 + IO 库菱形案例，果断收藏

Ne0inhk

23 Mar 2026 — 18 min read

✨ 孤廖：个人主页

🎯 个人专栏：《C++：从代码到机器》

🎯 个人专栏：《Linux系统探幽：从入门到内核》

🎯 个人专栏：《算法磨剑：用C++思考的艺术》

折而不挠，中不为下

文章目录

正文：
结语：

正文：

1. 继承的概念和定义

概念：

继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的⼿段，它允许我们在保持原有类特性的基础上进⾏扩展，增加⽅法(成员函数)和属性(成员变量)，这样产⽣新的类，称派⽣类。继承呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复⽤，继承是类设计层次的复⽤。

[代码解释]：

classStudent{public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证voidIdentify(){//...}//学习voidstudy(){//...}protected: string _name;//名字 string _tel;//电话 string _address;//地址int _age=18;//年龄int _stuid;// 学号 <- 学生特有的};classTeacher{// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证voididentity(){// ...}// 授课voidteaching(){//...}protected: string _name;//名字 string _tel;//电话 string _address;//地址int _age =18;//年龄 string _title;// 职称 <- 教师特有的};

可以看到我们Student 和Teacher 都有公共成员比如名字，电话，地址，年龄。。。
都有identity⾝份认证的成员函数，设计到两个类⾥⾯就是冗余的
当然他们还有不同的属性特征比如 Student 有学生id Teacher有职称或者相关函数等等
那么我们是否可以将公共的属性封装到一个公共类里而我们通过继承的方式或者这些属性呢？

下⾯我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复⽤这些成员，就不需要重复定义了，省去了很多⿇烦

classPersion{public://身份识别 比如进入图书馆 打卡教务系统 上班等等。。。voidIdentify(){ cout <<"void Identify()"<< _name << endl;}protected: string _name;//名字 string _tel;//电话 string _address;//地址int _age;//年龄};classStudent:publicPersion{public://学习voidstudy(){//...}protected:int _stuid;// 学号 <- 学生特有的};classTeacher:publicPersion{// 授课voidteaching(){//...}protected: string _title;// 职称 <- 教师特有的};

定义:

我们看到Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。(因为翻译的原因，所以
既叫基类/派⽣类，也叫⽗类/⼦类)

C++ 中的继承方式有三种：public, protected,private

参考图

针对某种父类成员来说，子类继承后是否可以访问继承的这个成员取决于父类的访问限定符和子类的继承方式。

基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员
还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问
它基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员在派⽣类的访问⽅式 == Min(成员在基类的访问限定符，继承⽅式)，public > protected >
private使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显
⽰的写出继承⽅式在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protetced/private继承，也不提倡使⽤
protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实
际中扩展维护性不强。

实例演⽰三种继承关系下基类成员的各类型成员访问关系的变化

public:

classPerson{public:voidPrint(){ cout << _name << endl;}protected: string _name="1";// 姓名private:int _age;// 年龄};classStudent:publicPerson{protected:int _stunum;// 学号};intmain(){ Student s; s.Print();return0;}

对于_name 最终的继承方式为protected 可以访问

protected:

该种继承模式下对于print 成员函数最终的继承方式为protected，在子类中该成员函数的访问权限为protected 类外不可访问

classPerson{public:voidPrint(){ cout << _name << endl;}protected: string _name="1";// 姓名private:int _age;// 年龄};classStudent:protectedPerson{protected:int _stunum;// 学号};intmain(){ Student s; s.Print();return0;}

private:
子类中关于父类的成员的全部访问权限为private 无论是子类内还是子类外全不可访问这些成员

classPerson{public:voidPrint(){ cout << _name << endl;}protected: string _name="1";// 姓名private:int _age;// 年龄};classStudent:privatePerson{protected:int _stunum;// 学号};intmain(){ Student s; s.Print(); s._name(); s._age;return0;}

继承类模板

template<classT>classStack:publicvector<T>{//成员函数voidpush(const T& x){//基类是模板类 子类访问父类的成员时 需要指定访问限定符//因为 模板类是按需实例化 不指定的话 找不到push_backvector<T>::push_back(x);}voidpop(){vector<T>::pop_bakc();}// ...};

2. 基类和派⽣类间的转换

• public继承的派⽣类对象可以赋值给基类的指针 / 基类的引⽤。这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分。基类对象不能赋值给派⽣类对象基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time Type
Information)的dynamic_cast 来进⾏识别后进⾏安全转换。

切片的图例化
Student 中的_No 是Student的独有成员将其切掉保留Student 中的父类成员整体给父类的指针或者引用

classPerson{protected: string _name;// 姓名 string _sex;// 性别int _age;// 年龄};classStudent:publicPerson{public:int _No;// 学号}intmain(){ Student s;//子类切片给父类的指针或者引用 Person* ptr =&s; Person& a = s;// ⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的 Person per = s;//父类对象不可以赋值给子类对象 编译会报错 s = per;return0;}

3. 继承中的作⽤域’

隐藏规则：

在继承体系中基类和派⽣类都有独⽴的作⽤域子类继承的父类可以把父类的所有成员看成一个整体本质就是一个自定义类对象（参考string）只不过继承的父类对象在子类的声明头部 -> 初始化列表中优先调用父类的构造函数初始化父类对象派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。
（在派⽣类成员函数中，可以使⽤基类::基类成员显⽰访问）子类继承父类后在子类外面调用子类的函数时优先扫描子类域如果没有才会扫描子类中父类对象的域需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。注意在实际中在继承体系⾥⾯最好不要定义同名的成员。(如果做了这件事难道不是违背祖师爷设计继承出来的意义么？)

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆classPerson{protected: string _name ="⼩李⼦";// 姓名int _num =111;// ⾝份证号};classStudent:publicPerson{public:voidPrint(){ cout <<" 姓名:"<< _name << endl; cout <<" ⾝份证号:"<< Person::_num << endl; cout <<" 学号:"<< _num << endl;}protected:int _num =999;// 学号};intmain(){ Student s1; s1.Print();return0;};

4. 派⽣类的默认成员函数

4个常⻅默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们⾃动⽣成⼀个，那么在派⽣类中，这⼏个成员函数是如何⽣成的呢？派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造
函数，则必须在派⽣类构造函数的初始化列表阶段显⽰调⽤派⽣类的拷⻉构造函数必须调⽤基类的拷⻉构造完成基类的拷⻉初始化派⽣类的operator=必须要调⽤基类的operator=完成基类的复制。需要注意的是派⽣类的
operator=隐藏了基类的operator=，所以显⽰调⽤基类的operator=，需要指定基类作⽤域派⽣类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派
⽣类对象先清理派⽣类成员再清理基类成员的顺序 满足先定义的类后析构这个设计要求派⽣类对象初始化先调⽤基类构造再调派⽣类构造。构造函数会先走初始化列表。而基类对象在子类成员变脸声明的头部派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。 (满足先定义的类后析构这个设计要求)因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同(这个我们多态章节会讲解)。那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以基类析构函数不加
virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系该点在下篇博客多态中详细阐述

这里在回顾下类的默认成员函数

[参考代码]：

测试父子类构造函数和析构函数的调用规则

classPerson{public:Person(constchar* name ="peter"):_name(name){ cout <<"Person()"<< endl;}Person(const Person& p):_name(p._name){ cout <<"Person(const Person& p)"<< endl;} Person&operator=(const Person& p){ cout <<"Person operator=(const Person& p)"<< endl;if(this!=&p) _name = p._name;return*this;}~Person(){ cout <<"~Person()"<< endl;}protected: string _name;// 姓名};classStudent:publicPerson{public:Student(constchar* name,int num):Person(name),_num(num){ cout <<"Student()"<< endl;}Student(const Student& s):Person(s),_num(s._num){ cout <<"Student(const Student& s)"<< endl;} Student&operator=(const Student& s){ cout <<"Student& operator= (const Student& s)"<< endl;if(this!=&s){// 构成隐藏，所以需要显⽰调⽤ Person::operator=(s); _num = s._num;}return*this;}~Student(){ cout <<"~Student()"<< endl;}protected:int _num;//学号};intmain(){ Student s1("jack",18); Student s2(s1); Student s3("rose",17); s1 = s3;return0;}

实现一个不能被继承的类

⽅法1：基类的构造函数私有，派⽣类的构成必须调⽤基类的构造函数，但是基类的构成函数私有化以
后，派⽣类看不⻅就不能调⽤了，那么派⽣类就⽆法实例化出对象。
⽅法2：C++11新增了⼀个final关键字，final修改基类，派⽣类就不能继承了

[代码参考]：

注意这里提供的代码时方法二：

// C++11的⽅法classBase final {public:voidfunc5(){ cout <<"Base::func5"<< endl;}protected:int a =1;private:}classDerive:publicBase{voidfunc4(){ cout <<"Derive::func4"<< endl;}protected:int b =2;};intmain(){ Base b; Derive d;return0;}

5. 继承与友元

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

但是该友元依旧可以访问基类的私有和保护成员

[代码参考]:

classPerson{public:friendvoidDisplay(const Person& p,const Student& s);protected: string _name;// 姓名};classStudent:publicPerson{protected:int _stuNum;// 学号};voidDisplay(const Person& p,const Student& s){ cout << p._name << endl; cout << s._stuNum << endl;}intmain(){ Person p; Student s;// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员// 解决⽅案：Display也变成Student 的友元即可Display(p, s);return0;}

6. 继承与静态成员

基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个派⽣类，都
只有⼀个static成员实例

即基类实例化的对象和派生类实例化的对象调用static成员时调用的是同一个

这里不做代码演示了各位可以自己私下验证
思路：验证基类和派生类中该static成员的地址是否相同

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

继承模型：

单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下⾯的对象成员模型构造，可以看出菱形继承有数据冗余和⼆义性的问题，在Assistant的对象中Person成员会有两份。⽀持多继承就⼀定会有菱形继承，像Java就直接不⽀持多继承，规避掉了这⾥的问题，所以***实践中我们也是不建议设计出菱形继承这样的模型的***

图片实例化

单继承

多继承

菱形继承

注意这里的菱形指的是继承关系图是闭环的类菱形图不一定为标准的菱形图

数据冗余：Assistan 会有两份Persion 造成数据的浪费二义性：Assistant 实例化的对象访问Persion类中的成员时不知道访问的是由Student 类继承下来的Persion 还是Teacher继承下来的Persion，这种歧义导致编译器无法区分而要想解决二义性需要指定继承的基类

【代码参考】:

classPersion{public: string _name;// 姓名};classStudent:publicPersion{protected:int _num;//学号};classTeacher:publicPersion{protected:int _id;// 职⼯编号};classAssistant:publicStudent,publicTeacher{protected: string _majorCourse;// 主修课程};intmain(){// 编译报错：error C2385: 对“_name”的访问不明确 Assistant a; a._name ="peter";// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决 a.Student::_name ="xxx"; a.Teacher::_name ="yyy";return0;}};

看编译器的报错

虚继承

使用虚继承可以解决菱形继承的数据冗余和访问时的二义性

【参考代码】:

classPersion{public: string _name;// 姓名};classStudent:virtualpublicPersion{protected:int _num;//学号};classTeacher:virtualpublicPersion{protected:int _id;// 职⼯编号};classAssistant:publicStudent,publicTeacher{protected: string _majorCourse;// 主修课程};intmain(){//使用虚继承可以解决 菱形继承导致的数据冗余和二义性 Assistant a; a._name ="peter"; a.Student::_name ="xxx"; a.Teacher::_name ="yyy";return0;}

菱形继承足够复杂时会出现各种问题所以在实际开发中我们可以实现多继承（符合语法设计）但是尽量避免菱形继承，或者说就不要设计菱形继承。我查询了下菱形继承的设计场景，结果是很少

以下是io库中的菱形继承

C++ 文档中库中关于此时设计的部分源代码

template<classCharT,classTraits= std::char_traits<CharT>>classbasic_ostream:virtualpublic std::basic_ios<CharT,Traits>{};template<classCharT,classTraits= std::char_traits<CharT>>classbasic_istream:virtualpublic std::basic_ios<CharT,Traits>{};

8. 继承和组合

public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象。组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象(比如适配器)继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为*⽩箱复⽤***(white-box reuse)。术语“⽩箱”是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可
⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为*⿊箱复⽤(black-box reuse)*，因为对象的内部细节是不可⻅的。对象只以“⿊箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装

程序的设计要求高内聚，内耦合，这样可以保证每个模块的稳定与高效
因此优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合

结语：

吃透 C++ 继承的这些知识点 —— 从访问权限的 “Min 规则” 到菱形继承的 “虚继承解决方案”，再到继承与组合的 “耦合度权衡”，你已经打通了面向对象进阶的关键一关。

不过继承的故事还没结束，它埋下的 “析构函数隐藏”“多态适配” 等伏笔，都要在下次的C++ 多态专题里揭晓答案。比如虚继承和多态的虚函数有何关联？菱形继承的内存布局如何支撑多态特性？

下一篇我们带着这些问题，深入探索多态的 “动态绑定” 魔法，继续完善面向对象知识体系。欢迎在评论区分享你对继承难点的理解，咱们一起为多态学习做好铺垫～