【探寻C++之旅】第七章：继承

前言

今天，我们继续踏入追寻C++的冒险历程。上一章我们简单介绍并且了解了C++中的STL。那么本章将为大家讲解C++作为面向对象编程的三大特性之一的继承。下面让我们一起来进入继承的学习。

1. 继承的概念

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

下⾯我们看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址/电话/年龄等相同的成员变量，都有identity成员函数，设计到两个类⾥⾯就是冗余的。当然他们也有⼀些不同的成员变量和函数，⽐如⽼师独有成员变量是职称，学⽣的独有成员变量是学号；学⽣的独有成员函数是学习，⽼师的独有成员函数是授课。

1. class Student
2. {
3. public:
4. // 用于⾝份认证
5. void identity()
6. {
7. // ...
8. }
9. // 学习
10. void study()
11. {
12. // ...
13. }
14. protected:
15. string _name = "张三"; // 姓名
16. int _age = 18; // 年龄
17. string _address; // 地址
18. string _tel; // 电话
20. string _stuid; // 学号
21. };
23. class Teacher
24. {
25. public:
26. // 用于⾝份认证
27. void identity()
28. {
29. // ...
30. }
31. // 授课
32. void teaching()
33. {
34. //...
35. }
36. protected:
37. string _name = "李四"; // 姓名
38. int _age = 32; // 年龄
39. string _address; // 地址
40. string _tel; // 电话
42. string _title; // 职称
43. };

复制代码

这种冗余该怎么解决呢？我们可以把公共的成员都放到另一个类：Person类中，并且使Student类和Teacher类都继承Person类，这样，在这两个类中就可以复⽤这些成员，就不需要重复定义了，省去了很多⿇烦。

1. class Person
2. {
3. public:
4. //用于⾝份认证
5. void identity()
6. {
7. cout << "void identity()" <<_name<< endl;
8. }
9. protected:
10. string _name = "张三"; // 姓名
11. string _address; // 地址
12. string _tel; // 电话
13. int _age = 18; // 年龄
14. };
16. class Student : public Person
17. {
18. public:
19. // 学习
20. void study()
21. {
22. // ...
23. }
24. protected:
25. string _stuid; // 学号
26. };
27. class Teacher : public Person
28. {
29. public:
30. // 授课
31. void teaching()
32. {
33. //...
34. }
35. protected:
36. string title; // 职称
37. };
38. int main()
39. {
40. Student s;
41. Teacher t;
43. s.identity();
44. t.identity();
45. return 0;
46. }

复制代码

2. 继承的定义

2.1 定义格式

继承的语法如下图所示，在类名后面加冒号+ 继承方式 + 继承的类名

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

继承方式有三种：

• public继承
• protected继承
• private继承

2.2 继承基类成员访问⽅式的变化

可以发现，继承方式与我们的访问限定符是一样的。在前面说到访问限定符时，我们知道public修饰的成员是可以在类外直接访问的，而protected和private修饰的成员是不能够在类外直接访问的。既然protected和private在这里的功能相同，那为什么会有两个呢，它们之间有没有什么区别呢？其实在普通的类中它们两个是没有什么区别的，使用哪个都可以。但是在继承中，它们的区别就会显现出来。我们先来看一看继承方式不同对基类的影响：

类成员 / 继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected的成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

上表的含义是基类的成员通过不同的继承方式继承后在其派生类中会成为哪种类型的成员。

需要注意的是：

• 基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问它。

基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类中能访问，就定义为protected。可以看出protected成员限定符是因继承才出现的。

实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员在派⽣类的访问⽅式 == Min(成员在基类的访问限定符，继承⽅式)。（public > protected > private）

使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显⽰的写出继承⽅式。在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protetced和private继承，也不提倡使⽤protetced和private继承，因为protetced和private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实际中扩展维护性不强。

3. 继承类模板

前面我们学习了stack是容器适配器，通过对一般容器的接口进行封装得到的。那么我们是不是也可以通过继承的方式去实现呢？当然是可以的，看下列代码：

1. namespace My
2. {
3. //template<class t="">
4. //class vector
5. //{};
7. template<class t="">
8. class stack : public std::vector<t>
9. {
10. public:
11. void push(const T& x)
12. {
13. // 基类是类模板时，需要指定⼀下类域，
14. // 否则编译报错:error C3861: “push_back”: 找不到标识符
15. // 因为stack<int>实例化时，也实例化vector<int>了
16. // 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
17. vector<t>::push_back(x);
18. //push_back(x);
19. }
20. void pop()
21. {
22. vector<t>::pop_back();
23. }
24. const T& top()
25. {
26. return vector<t>::back();
27. }
28. bool empty()
29. {
30. return vector<t>::empty();
31. }
32. };
33. }
35. int main()
36. {
37. My::stack<int> st;
38. st.push(1);
39. st.push(2);
40. st.push(3);
42. while (!st.empty())
43. {
44. cout << st.top() << " ";
45. st.pop();
46. }
47. return 0;
48. }

复制代码

在继承类模板时需要注意使用基类的成员时需要指定类域，这是因为模板是按需实例化的，如果没有用到某个成员函数那么是不会实例化出来的，这样当我们在派生类直接使用基类的成员函数时会找不到该函数，导致编译器报错。

4. 基类和派生类间的转换

• public继承的派⽣类对象 可以赋值给 基类的指针 / 基类的引⽤。这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分。

如上图所示，我们将派生类Student的对象赋值给基类的指针，那么这个指针指向的内容只包括派生类Student中的基类部分，引用同理。至于能否将基类的指针和引用能否赋值给派生类呢？答案是可以的，我们可以将基类的指针或者引⽤通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time Type Information)的dynamic_cast 来进⾏识别后进⾏安全转换（了解即可，后续章节会进行讲解）。

• 基类对象不能赋值给派⽣类对象。

派生类对象可以赋值给基类（通过调用基类的拷贝构造函数，下面会将）。

1. class Person
2. {
3. protected :
4. string _name; // 姓名
5. string _sex; // 性别
6. int _age; // 年龄
7. };
8. class Student : public Person
9. {
10. public :
11. int _No ; // 学号
12. };
13. int main()
14. {
15. Student sobj ;
16. // 1.派⽣类对象可以赋值给基类的指针/引⽤
17. Person* pp = &sobj;
18. Person& rp = sobj;
19. // 2.派⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
20. Person pobj = sobj;
21. //3.基类对象不能赋值给派⽣类对象，这⾥会编译报错
22. //sobj = pobj;
23. return 0;
24. }

复制代码

5. 继承中的作用域

5.1 隐藏规则

在继承体系中基类和派⽣类都有独⽴的作⽤域。 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派⽣类成员函数中，可以使⽤ 基类::基类成员 显⽰访问）需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏，并不会构成重载，因为它们不在同一作用域。

1. // Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
2. class Person
3. {
4. protected :
5. string _name = "⼩李⼦"; // 姓名
6. int _num = 111; // ⾝份证号
7. };
8. class Student : public Person
9. {
10. public:
11. void Print()
12. {
13. cout<<" 姓名:"<<_name<< endl;
14. cout<<" ⾝份证号:"<<person::_num<< endl;="" cout<<"="" 学号:"<<_num<<endl;="" }="" protected:="" int="" _num="999;" 学号="" };="" main()="" {="" student="" s1;="" s1.print();="" return="" 0;="" [="" code]="" <p=""><img src="https://i-blog.csdnimg.cn/img_convert/48a4eb250ab400bef51e70034ccf1827.png" alt="QQ20250228-182057"><p></p>
16. <p>注意在实际中在继承体系⾥⾯最好不要定义同名的成员。</p>
18. <h3>6. 派生类的默认成员函数</h3>
19. <p>在前面我们讲解类和对象（详情点击）时讲到了类的默认成员函数，一共有六个，其中有四个常用的。<strong>默认</strong>的意思就是指我们不写，编译器会变我们⾃动⽣成⼀个，那么在派⽣类中，这⼏个成员函数是如何⽣成的呢？ 我们需要注意下面几个要点：</p>
20. <ul><li>派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派⽣类构造函数的初始化列表阶段显⽰调⽤。</li><li>派⽣类的拷⻉构造函数必须调⽤基类的拷⻉构造完成基类的。</li><li>派⽣类的operator=必须要调⽤基类的operator=完成基类那部分的复制。需要注意的是派⽣类的operator=隐藏了基类的operator=，所以显⽰调⽤基类的operator=，需要指定基类作⽤域。</li><li>派⽣类的析构函数会在被调⽤完成后<strong>⾃动</strong>调⽤基类的析构函数清理基类成员，因此当派生类的析构函数需要显示写时无需再调用基类的析构函数。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序。</li><li>派⽣类对象初始化先调⽤基类构造再调派⽣类构造。</li><li>派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。</li><li>因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同(多态下章进行讲解)。那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系（当前了解即可）。</li></ul>
21. <p><img src="https://i-blog.csdnimg.cn/img_convert/170a73d1c9442b6a0741e943595c34a2.png" alt="QQ20250228-183430"></p>
22. <p>上图即为两者构造与析构之间的先后关系。下面让我们来尝试一下再派生类中如何显示写出这几个默认成员函数。</p>
23. [code]class Person
24. {
25. public :
26. Person(const char* name = "peter")
27. : _name(name )
28. {
29. cout<<"Person()" <<endl; }="" person(const="" person&="" p)="" :="" _name(p._name)="" {="" cout<<"person(const="" p)"="" <<endl;="" operator="(const" p="" )="" cout<<"person="" p)"<<="" endl;="" if="" (this="" !="&p)" _name="p" ._name;="" return="" *this="" ;="" ~person()="" cout<<"~person()"="" protected="" string="" 姓名="" };="" class="" student="" public="" person="" student(const="" char*="" name,="" int="" num)="" person(name)="" ,="" _num(num="" cout<<"student()"="" student&="" s)="" person(s)="" _num(s="" ._num)="" cout<<"student(const="" s)"="" <<endl="" s="" cout<<"student&="" s)"<<="" 构成隐藏，所以需要显⽰调⽤="" person::operator="(s);" _num="s" ._num;="" ~student()="" cout<<"~student()"="" 学号="" main()="" s1="" ("jack",="" 18);="" s2="" (s1);="" s3="" ("rose",="" 17);="" 0;="" [="" code]="" <p=""><img src="https://i-blog.csdnimg.cn/img_convert/d48c6262452a5771eda99636b66e54a9.png" alt="QQ20250228-184214"><p></p>
30. <h3>7. 实现一个不能被继承的类</h3>
31. <ul><li>⽅法1：基类的构造函数私有，派⽣类的构成必须调⽤基类的构造函数，但是基类的构成函数私有化以后，派⽣类看不⻅就不能调⽤了，那么派⽣类就⽆法实例化出对象。</li><li>⽅法2：C++11新增了⼀个final关键字，使用final修饰基类，派⽣类就不能继承该类了。</li></ul>
32. [code]// C++11的⽅法
33. class Base final
34. {
35. public:
36. void func5() { cout << "Base::func5" << endl; }
37. protected:
38. int a = 1;
39. private:
40. // C++98的⽅法
41. /*Base()
42. {}*/
43. };
45. class Derive :public Base
46. {
47. public:
48. void func4() { cout << "Derive::func4" << endl; }
49. protected:
50. int b = 2;
51. };
52. int main()
53. {
54. Base b;
55. Derive d;
56. return 0;
57. }

复制代码

上述代码无法通过编译，会产生报错，因为被final修饰的类无法被继承

7. 继承与友元

友元关系不能被继承，也就是说基类友元不能访问派⽣类私有和保护成员。一个很简单的例子就可以理解，父亲的朋友一定是我的朋友吗？当然不是，只有通过我们自己的努力才能使父亲的朋友也成为我的朋友。

1. class Student;
2. class Person
3. {
4. public:
5. friend void Display(const Person& p, const Student& s);
6. protected:
7. string _name; // 姓名
8. };
9. class Student : public Person
10. {
11. protected:
12. int _stuNum; // 学号
13. };
14. void Display(const Person& p, const Student& s)
15. {
16. cout << p._name << endl;
17. cout << s._stuNum << endl;
18. }
19. int main()
20. {
21. Person p;
22. Student s;
23. // 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
24. // 解决⽅案：Display也变成Student 的友元即可
25. Display(p, s);
26. return 0;
27. }

复制代码

8. 继承与静态成员

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

1. class Person
2. {
3. public:
4. string _name;
5. static int _count;
6. };
8. int Person::_count = 0;
10. class Student : public Person
11. {
12. protected:
13. int _stuNum;
14. };
16. int main()
17. {
18. Person p;
19. Student s;
20. // 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
21. // 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
22. cout << &p._name << endl;
23. cout << &s._name << endl;
24. // 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
25. // 说明派⽣类和基类共⽤同⼀份静态成员
26. cout << &p._count << endl;
27. cout << &s._count << endl;
28. // 公有的情况下，⽗类和派⽣类指定类域都可以访问静态成员
29. cout << Person::_count << endl;
30. cout << Student::_count << endl;
31. return 0;
32. }

复制代码

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

9.1 继承模型

• 单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承。

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

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

1. class Person
2. {
3. public:
4. string _name; // 姓名
5. };
7. class Student : public Person
8. {
9. protected:
10. int _num; //学号
11. };
13. class Teacher : public Person
14. {
15. protected:
16. int _id; // 职⼯编号
17. };
19. class Assistant : public Student, public Teacher
20. {
21. protected:
22. string _majorCourse; // 主修课程
23. };
25. int main()
26. {
27. // 编译报错：error C2385: 对“_name”的访问不明确
28. Assistant a;
29. a._name = "peter";
30. // 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
31. a.Student::_name = "xxx";
32. a.Teacher::_name = "yyy";
33. return 0;
34. }

复制代码

9.2 虚继承

为了解决菱形继承中数据冗余和二义性的问题，C++中提出来了另一个概念：虚继承。虚继承即是在菱形继承的中间，也就是继承同一个类的若干个派生类在继承时加上virtual关键字，如下列代码所示：

1. class Person
2. {
3. public:
4. string _name; // 姓名
6. /*int _tel;
7. int _age;
8. string _gender;
9. string _address;*/
11. // ...
12. };
14. // 使⽤虚继承Person类
15. class Student : virtual public Person
16. {
17. protected:
18. int _num; //学号
19. };
21. // 使⽤虚继承Person类
22. class Teacher : virtual public Person
23. {
24. protected:
25. int _id; // 职⼯编号
26. };
28. // 教授助理
29. class Assistant : public Student, public Teacher
30. {
31. protected:
32. string _majorCourse; // 主修课程
33. };
35. int main()
36. {
37. // 使⽤虚继承，可以解决数据冗余和⼆义性
38. Assistant a;
39. a._name = "peter";
40. return 0;
41. }

复制代码

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，⽆论是使⽤还是底层都会复杂很多。当然有多继承语法⽀持，就⼀定存在会设计出菱形继承，像Java是不⽀持多继承的，就避开了菱形继承。

其实在C++中是存在菱形继承的，如我们所熟知的iostream，这就是一个菱形继承的例子。当然，菱形继承能不用就尽量不要使用。

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

10. 继承和组合

• public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象。

继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤(white-box reuse)。术语“⽩箱”是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可⻅ 。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。

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

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

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

在设计程序时，我们要尽可能的做到低耦合，高聚合。

尾声

若有纰漏或不足之处欢迎大家在评论区留言或者私信，同时也欢迎各位一起探讨学习。感谢您的观看！