【C++：继承】C++面向对象继承全面解析：派生类构造、多继承、菱形虚拟继承与设计模式实践
🔥艾莉丝努力练剑：个人主页
❄专栏传送门：《C语言》、《数据结构与算法》、C/C++干货分享&学习过程记录、Linux操作系统编程详解、笔试/面试常见算法：从基础到进阶
⭐️为天地立心，为生民立命，为往圣继绝学，为万世开太平
🎬艾莉丝的简介：
🎬艾莉丝的C++专栏简介：
目录
4.4.1 间接实现：【C++98】构造函数私有的类不能被继承
C++的两个参考文档
老朋友（非官方文档）：cplusplus
官方文档（同步更新）：cppreference
4 ~> 派生类的默认成员函数专题
4.4 实现一个不可继承类实现
4.4.1 间接实现：【C++98】构造函数私有的类不能被继承
基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。
运行一下——
这里必须调用基类的构造，但是基类这里是私有的，看不见，所以就不能再调用了。
4.4.2 直接实现：final关键字修改基类
C++11新增了一个final关键字，final修改基类，派生类就不能继承了。
我们同样运行一下——
4.4.3 代码实现
// C++11的方法 class Base final { public: void func5() { cout << "Base::func5" << endl; } protected: int a = 1; private: // C++98的方法 /*Base() {}*/ }; class Derive :public Base { void func4() { cout << "Derive::func4" << endl; } protected: int b = 2; }; int main() { Base b; Derive d; return 0; }4.4.4 final关键字
在本文博主不展开讲，下篇博客，博主会介绍C++进阶中又一个重要的模块——【多态】，在【多态】中，博主会介绍两个涉及到【多态】中的重写相关知识点的关键字：override和final。
也就是说，final充当了两个作用——
（1）直接实现一个不能被继承的类（【继承】篇涉及知识点）；
（2）不让重写基类虚函数（【多态】篇即将涉及的知识点）。
5 ~> 继承体系中的友元关系
5.1 友元与继承的关系特性
友元关系不能继承。
这句话也就是说基类友元不能访问派生类私有和保护成员。
5.2 解决方案
把派生类也变成基类的友元的友元即可。
5.3 最佳实践
5.3.1 正确代码演示
// 前置声明 class Student; class Person { // 友元关系不能被子类继承 friend void Display(const Person& p, const Student& s); public: 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; // 编译报错：error C2248：“Student::_stuNum”：无法访问 protected 成员 // 解决方案：Display也变成Student 的友元即可 Display(p, s); return 0; }运行一下——
这段代码是能顺利运行的，但是，我们看下面这段代码——
class Person { // 友元关系不能被子类继承 friend void Display(const Person& p, const Student& s); public: 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; // 编译报错：error C2248：“Student::_stuNum”：无法访问 protected 成员 // 解决方案：Display也变成Student 的友元即可 Display(p, s); return 0; }5.3.2 前置声明的必要性
不加前置声明会报下面的错——
5.3.3 友元关系不能继承
因为友元关系不能继承，因此我们要给派生类也变成基类友元的友元。
6 ~> 静态成员在继承中的特性
6.1 静态成员共享机制：父子共用同一份
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个static成员实例。
6.2 静态与非静态成员对比
6.2.1 非静态成员：实例独立
非静态成员的继承是父类和子类各一份，地址不一样。
6.2.2 静态成员：类间共享
静态成员的继承是父类和子类共用同一份，地址也一样。
6.3 实践出真知：静态成员继承实践案例
class Person { public: string _name; static int _count; }; // 静态成员会被继承 int Person::_count = 10; 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; }运行一下——
如上图所示。
6.4 共用一份的体现
7 ~> 单继承 vs 多继承（以及菱形继承问题详解）
事先说明：多继承是个大坑！！！
7.1 单继承 vs 多继承
7.1.1 概念对比
7.1.2 最佳实践
class Person { public: Person(const char* name) :_name(name) { } public: string _name; // 姓名 //int* _age; // 年龄 //int _tel; // 电话 //string _address; // 地址 }; //class Student : public Person class Student : virtual public Person // 虚继承 { public: Student(const char* name,int num) :Person(name) ,_num(num) { } protected: int _num; // 学号 }; //class Teacher : public Person class Teacher : virtual public Person { public: Teacher(const char* name, int id) :Person(name) ,_id(id) { } protected: int _id; // 教职工编号 };7.2 菱形继承问题详解
7.2.1 菱形继承的概念
7.2.2 菱形继承的数据冗余与二义性问题
基类数据越多，这两个问题越严重。
数据冗余：如下图所示，Person有两个——
二义性：访问不明确~>指定类域勉强解决
7.2.3 虚继承解决方案
菱形继承——多继承延伸的坑
多继承不是问题，多继承实现的菱形继承才是问题。
因此设计了“菱形虚拟继承”来解决，下面我们会介绍虚继承。
7.2.4 虚继承机制与virtual关键字
关键词virtual加在腰部位置，如下图所示——
都加上virtual可不可以？——当然不行。
换个说法，药能多吃吗？会影响底层的空间模型，能编译通过但底层空间会乱。
虚继承太复杂了，无论是使用还是底层，都太复杂。
不要玩菱形继承！！！当然，菱形继承也是有应用的，库里面的IO库就是搞成菱形继承的，IO库的使用会专门在IO库讲。
7.2.5 菱形继承的问题
7.2.6 实践
class Person { public: Person(const char* name) :_name(name) { } public: string _name; // 姓名 //int* _age; // 年龄 //int _tel; // 电话 //string _address; // 地址 }; //class Student : public Person class Student : virtual public Person // 虚继承 { public: Student(const char* name,int num) :Person(name) ,_num(num) { } protected: int _num; // 学号 }; //class Teacher : public Person class Teacher : virtual public Person { public: Teacher(const char* name, int id) :Person(name) ,_id(id) { } protected: int _id; // 教职工编号 }; class Assistant : public Student, public Teacher { public: Assistant(const char* name1,const char* name2,const char* name3) :Person(name1) ,Student(name2,1) ,Teacher(name3,2) ,_majorCourse("计算机") { } protected: string _majorCourse; // 主修课程 }; int main() { // 思考一下这里a对象中_name是“张三”，“李四”，“王五”中的哪一个？ Assistant a("张三", "李四", "王五"); // 编译报错：error C2385：对“_name”的访问不明确 /*Assistant a;*/ a._name = "peter"; // 需要显示指定访问哪个基类的成员可以解决二义性问题，但是数据冗余问题无法解决 a.Student::_name = "xxx"; a.Teacher::_name = "yyy"; // 再比如 a.Student::_name = "小黄"; a.Teacher::_name = "黄老师"; cout << endl; return 0; }运行一下——
7.2.7 可以设计出多继承，不建议设计出菱形继承
我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。当然有多继承语法支持，就一定存在会设计出菱形继承，像Java是不支持多继承的，就避开了菱形继承。
7.3 IO库中的菱形虚拟继承
7.4 多继承中的指针偏移问题
7.4.1 题目
下面说法正确的是（ ）
A. p1 == p2 == p3 B. p1 < p2 < p3
C. p1 == p3 != p2 D. p1 != p2 != p3
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; }7.4.2 答案解析
正确答案：C。
7.4.3 运行
运行一下——
8 ~> 继承与组合设计模式对比
8.1 基本概念：is-a vs has-a
1、public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
2、组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
3、继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-boxreuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对派生类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
4、对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-boxreuse），因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
5、优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承（is-a）那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a）也适合组合(has-a)，就用组合。
8.2 继承与组合关系对比
8.3 最佳实践
// 继承和组合 // Tire(轮胎)和Car(⻋)更符合has-a的关系 class Tire { protected: string _brand = "Michelin"; // 品牌 size_t _size = 17; // 尺寸 }; class Car { protected: string _colour = "白色"; // 颜色 string _num = "陕ABIT00"; // 车牌号 Tire _t1; // 轮胎 Tire _t2; // 轮胎 Tire _t3; // 轮胎 Tire _t4; // 轮胎 }; class BMW : public Car { public: void Drive() { cout << "好开-操控" << endl; } }; // Car和BMW/Benz更符合is-a的关系 class Benz : public Car { public: void Drive() { cout << "好坐-舒适" << endl; } }; template<class T> class vector {}; // stack和vector的关系，既符合is-a，也符合has-a template<class T> class stack : public vector<T> {}; template<class T> class stack { public: vector<T> _v; }; int main() { return 0; }is-a用继承，has-a用组合。
// 继承和组合 // Tire(轮胎)和Car(⻋)更符合has-a的关系 // 轮胎类 class Tire { protected: string _brand = "Michelin"; size_t _size = 17; }; // 汽车基类 class Car { protected: string _colour = "白色"; string _num = "陕ABIT00"; Tire _tires[4]; // 使用数组更合适 }; // 派生类 class BMW : public Car { public: void Drive() { cout << "好开-操控" << endl; } }; class Benz : public Car { public: void Drive() { cout << "好坐-舒适" << endl; } }; // 正确的stack实现 template<class T> class Stack { private: vector<T> _v; // 组合关系 public: void push(const T& x) { _v.push_back(x); } void pop() { if (!_v.empty()) _v.pop_back(); } T& top() { if (!_v.empty()) return _v.back(); throw std::out_of_range("Stack is empty"); } bool empty() const { return _v.empty(); } size_t size() const { return _v.size(); } }; int main() { BMW bmw; bmw.Drive(); Stack<int> s; s.push(1); s.push(2); cout << s.top() << endl; // 输出2 return 0; }运行一下——
8.4 继承 vs 组合
8.4.1 白盒复用与黑盒复用
白盒测试：更加难，一般由研发人员写并且测试，看得见、透明——保护、私有都可使用；
黑盒测试：看不见，不透明；
白盒 / 黑盒好坏的依据是从软件设计角度出发的。
8.4.2 软件设计中的选择策略
高内聚，低耦合——可维护性（其中一个修改，另一个不受影响）。
8.4.3 模块
打成一个个模块，哪个出问题改哪个，不受影响。
组件：静态库、动态库——不可执行的二进制文件——
（1）编译时间降低；
（2）看不到源码（二进制编译）。
8.4.4 博主手记
如下图所示——
8.5 继承与组合最佳实践指南：继承和组合哪个更好？
实践的角度：优先使用组合；既符合继承也符合组合，我们使用组合；但是要注意：是“优先使用组合”，不是必须使用，但是像多态这些需要继承的地方还是要用继承。
完整代码示例与实践演示
Test.cpp：
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> #include<vector> #include<list> using namespace std; //// 前置声明 //class Student; // //class Person //{ // // 友元关系不能被子类继承 // friend void Display(const Person& p, const Student& s); //public: //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; // // 编译报错：error C2248：“Student::_stuNum”：无法访问 protected 成员 // // 解决方案：Display也变成Student 的友元即可 // // Display(p, s); // // return 0; //} //class Person //{ //public: // string _name; // static int _count; //}; // //// 静态成员会被继承 //int Person::_count = 10; // //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; //} //class Person //{ //public: // Person(const char* name) // :_name(name) // { } // //public: // string _name; // 姓名 // //int* _age; // 年龄 // //int _tel; // 电话 // //string _address; // 地址 //}; ////class Student : public Person //class Student : virtual public Person // 虚继承 //{ //public: // Student(const char* name,int num) // :Person(name) // ,_num(num) // { } //protected: // int _num; // 学号 //}; // ////class Teacher : public Person //class Teacher : virtual public Person //{ //public: // Teacher(const char* name, int id) // :Person(name) // ,_id(id) // { } //protected: // int _id; // 教职工编号 //}; // //class Assistant : public Student, public Teacher //{ //public: // Assistant(const char* name1,const char* name2,const char* name3) // :Person(name1) // ,Student(name2,1) // ,Teacher(name3,2) // ,_majorCourse("计算机") // { } // //protected: // string _majorCourse; // 主修课程 //}; // //int main() //{ // // 思考一下这里a对象中_name是“张三”，“李四”，“王五”中的哪一个？ // Assistant a("张三", "李四", "王五"); // // // 编译报错：error C2385：对“_name”的访问不明确 // /*Assistant a;*/ // a._name = "peter"; // // a.Student::_name = "小黄"; // a.Teacher::_name = "黄老师"; // // cout << endl; // // return 0; //} //// 继承 is-a //class stack : public vector //{ }; // //// 组合 has-a //class stack //{ // vector _v; //}; //// 写一个不能被继承的类 // //class Base //{ //public: // void func5() { cout << "Base::func5" << endl; } //protected: // int a = 1; //private: // // C++98的办法：构造函数私有的类不能被继承 —— 间接 // Base() // {} //}; //class Derive : Base //{}; class Base final { public: void func5() { cout << "Base::func5" << endl; } protected: int a = 1; }; class Derive : Base // 修饰基类，派生类不能再被继承了 —— 直接 {}; int main() { Derive d; return 0; }结尾
往期回顾：
【C++：继承】面向对象编程精要：C++继承机制深度解析与最佳实践
结语：都看到这里啦！那请大佬不要忘记给博主来个“一键四连”哦！
🗡博主在这里放了一只小狗，大家看完了摸摸小狗放松一下吧！🗡
૮₍ ˶ ˊ ᴥ ˋ˶₎ა
