【C++进阶】Cyber骇客的赛博血统上传——【面向对象之 继承 】一文带你搞懂面向对象编程的三要素之————继承

⚡ CYBER_PROFILE ⚡
/// SYSTEM READY ///

---

WARNING \]: DETECTING HIGH ENERGY **🌊 🌉 🌊 心手合一 · 水到渠成**  |------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| | **\>\>\> ACCESS TERMINAL \<\<\<** || | [**\[ 🦾 作者主页 \]**](https://blog.csdn.net/fengtinghuqu520?spm=1000.2115.3001.5343) | [**\[ 🔥 C语言核心 \]**](https://blog.csdn.net/fengtinghuqu520/category_12955956.html) | | [**\[ 💾 编程百度 \]**](https://blog.csdn.net/fengtinghuqu520/category_13083835.html) | [**\[ 📡 代码仓库 \]**](https://blog.csdn.net/fengtinghuqu520/article/details/147275999?spm=1001.2014.3001.5502) | --------------------------------------- Running Process: 100% \| Latency: 0ms *** ** * ** *** #### 索引与导读 * [1. 继承的核心概念](#1. 继承的核心概念) * [2. 继承的基本语法](#2. 继承的基本语法) * * [2）继承方式(权限继承矩阵表)](#2）继承方式(权限继承矩阵表)) * [3. 继承与模板的结合](#3. 继承与模板的结合) * * [3.1）类 继承 类模板](#3.1）类 继承 类模板) * [3.2）类模板 继承 类模板](#3.2）类模板 继承 类模板) * [3.3）模板继承的语法坑](#3.3）模板继承的语法坑) * * [如何破解？（三大解法）](#如何破解？（三大解法）) * [4. 基类 和 派生类 之间的转换](#4. 基类 和 派生类 之间的转换) * * [4.1）普通类型转换：必须加 const](#4.1）普通类型转换：必须加 const) * [4.2）继承体系的特殊处理：不需要 const](#4.2）继承体系的特殊处理：不需要 const) * [4.3）对象切片](#4.3）对象切片) * [4.4）基类绝对不能赋值给派生类](#4.4）基类绝对不能赋值给派生类) * [4.5）向下转型的安全隐患与 RTTI](#4.5）向下转型的安全隐患与 RTTI) * * [1）强制类型转换（极其危险）](#1）强制类型转换（极其危险）) * [2）安全的向下转型（dynamic_cast 安全转换）](#2）安全的向下转型（dynamic_cast 安全转换）) * [总结](#总结) * [5. 继承中的作用域](#5. 继承中的作用域) * * [5.1）基类和派生类都有独立的作用域](#5.1）基类和派生类都有独立的作用域) * [5.2）同名成员的"隐藏"与 基类:: 显式访问](#5.2）同名成员的“隐藏”与 基类:: 显式访问) * [5.3）基类与派生类中关于 函数重载 的潜规则](#5.3）基类与派生类中关于 函数重载 的潜规则) * [6. 派生类的默认成员函数](#6. 派生类的默认成员函数) * * [6.1）❗我们写这几个默认成员函数，首先思考几个原则性的问题](#6.1）❗我们写这几个默认成员函数，首先思考几个原则性的问题) * [6.2）代码级剖析](#6.2）代码级剖析) * [6.3）图表解析](#6.3）图表解析) * [7. 实现一个不能被继承的类](#7. 实现一个不能被继承的类) * * [方法 1：利用构造函数的私有性（C++98 时代的"黑科技"）](#方法 1：利用构造函数的私有性（C++98 时代的“黑科技”）) * [方法 2：使用 final 关键字（C++11 现代标准，最推荐）](#方法 2：使用 final 关键字（C++11 现代标准，最推荐）) * [8. 继承与友元](#8. 继承与友元) * [9. 继承与静态成员](#9. 继承与静态成员) * [⭕10. 单继承、多继承 及其 菱形继承问题](#⭕10. 单继承、多继承 及其 菱形继承问题) * * [10.1）单继承](#10.1）单继承) * [10.2）多继承](#10.2）多继承) * [10.3）菱形继承问题](#10.3）菱形继承问题) * [10.4）虚继承](#10.4）虚继承) * [10.5）多继承中的指针偏移问题](#10.5）多继承中的指针偏移问题) * [11. 继承与组合](#11. 继承与组合) * * [为什么优先使用组合（Has-A）？](#为什么优先使用组合（Has-A）？) * [什么时候必须用继承](#什么时候必须用继承) * [💻结尾--- 核心连接协议](#💻结尾— 核心连接协议) ## 1. 继承的核心概念 在`C++`中，继承是面向对象编程`（OOP）`的**三大基石之一（封装、继承、多态）** * **基类 (Base Class / Parent Class)**：被继承的类，包含通用的属性和方法。 * **派生类 (Derived Class / Child Class)**：继承基类的类，可以添加新成员或修改（重写）基类的行为。 *** ** * ** *** ## 2. 继承的基本语法 ```cpp class Base { /* ... */ }; class Derived : [继承方式] Base { /* ... */ }; ``` ### 2）继承方式(权限继承矩阵表) 无论哪种继承方式，基类的 `private` 成员在派生类中**永远不可见**（不可直接访问） * **继承方式改变的是基类的 `public` 和 `protected` 成员在派生类中的"降级"规则：** | 继承方式 | 基类成员访问级别 | 在派生类中的访问级别 | |------------------|-------------|-----------------| | **public 继承** | `public` | 保持为 `public` | | | `protected` | 保持为 `protected` | | | `private` | 不可见（存在但无法直接访问） | | **protected 继承** | `public` | 降级为 `protected` | | | `protected` | 降级为 `protected` | | | `private` | 不可见（存在但无法直接访问） | | **private 继承** | `public` | 降级为 `private` | | | `protected` | 降级为 `private` | | | `private` | 不可见（存在但无法直接访问） | *** ** * ** *** ## 3. 继承与模板的结合 ### 3.1）类 继承 类模板 基类是一个模板，但派生类是一个普通的类 * **核心逻辑：** 在继承时，你必须给基类添加具体的类型（实例化） ```cpp template class Base { public: T data; void print() { cout << "Base" << endl; } }; // 派生类是普通类，但必须把基类模板的具体类型写死（比如 int） class Derived : public Base { public: void doSomething() { data = 10; // 这里的 data 已经被确定为 int 类型 print(); } }; ``` **总结：** 编译器把 Base 当作一个已经完全确定的类来对待 *** ** * ** *** ### 3.2）类模板 继承 类模板 * **核心逻辑：** 派生类本身也是一个模板。派生类需要接收类型参数，并且通常要把这个参数继续传递给基类 ```cpp template class Base { public: T value; }; template class Derived :public Base { public: T getValue() { return this->value; // 稍后解释为什么这里推荐加 this-> } }; Derived d; ``` `return this->value;` ------------ **稍后解释为什么这里推荐加 `this->`** *** ** * ** *** ### 3.3）模板继承的语法坑 **在普通的继承中** ，子类可以直接使用父类的 public 和 protected 成员 但在模板继承中，如果你直接使用父类的成员变量或函数，编译器会无情地报错："**找不到该标识符**"！ ```cpp template class Base { public: void foo() {} }; template class Derived : public Base { public: void bar() { foo(); // ❌ 编译报错！找不到 foo()！ } }; ``` **为什么会这样？（底层原理）** `C++` 编译器在解析模板时使用**两阶段名字查找** 1. **第一阶段（定义时）** ：编译器检查模板的语法。此时，它不知道 `T` 是什么，因此它也不知道 `Base` 到底是个什么东西（因为你以后可能会写一个针对特定类型的模板特化，而那个特化版本里可能根本没有 `foo()` 函数）。所以，编译器拒绝去 `Base` 里查找名字 2. **第二阶段（实例化时）** ：只有当你真正写出 `Derived d;` 时，编译器才开始把具体的类型代入 *** ** * ** *** #### 如何破解？（三大解法） 为了在第一阶段安抚编译器，你需要显式地告诉编译器："这个名字不是凭空出现的，它依赖于模板参数，去父类里找！" 1. **使用 `this->`（最推荐、最优雅）：** ```cpp void bar() { this->foo(); } // 告诉编译器，foo 是属于当前对象（派生自 Base）的成员函数 ``` 2. **使用 `Base::` 作用域解析：** ```cpp void bar() { Base::foo(); } // 显式指明是从父类来的 // ▲ 警告：如果 foo() 是虚函数，这种写法会关闭多态机制（静态绑定），要小心使用！ ``` 3. **使用 `using` 声明** ```cpp using Base::foo; void bar() { foo(); } ``` *** ** * ** *** ## 4. 基类 和 派生类 之间的转换 * 我们先定义一个基础的继承体系，作为后面所有代码的演示平台： ```cpp #include #include using namespace std; // 基类 class Base { public: int base_data = 10; virtual ~Base() = default; // 为了支持后面的 dynamic_cast }; // 派生类 class Derived : public Base { public: int derived_data = 20; }; ``` `virtual ~Base() = default;` 只要你的类打算被别人继承，它的析构函数就必须是 `virtual` 的 这个我们后期会讲虚函数的作用 *** ** * ** *** ### 4.1）普通类型转换：必须加 const ```cpp int a = 1; // double& d = a; // ❌ 编译报错！ const double& d = a; // ✅ 正确。因为 int 转 double 会生成一个匿名的 double 临时变量(右值) ``` **临时变量为常量** *** ** * ** *** ### 4.2）继承体系的特殊处理：不需要 const ```cpp Derived derived_obj; // ✅ 正确且安全！没有产生任何临时对象！ Base& base_ref = derived_obj; Base* base_ptr = &derived_obj; // 验证：它们操作的是同一块内存 base_ref.base_data = 999; cout << derived_obj.base_data << endl; // 输出 999 ``` 当编译器看到 `Base& = derived_obj` 时，它没有去创建一个新的 `Base` 临时对象。**它只是在底层做了一个指针偏移，让 `base_ref `直接指向 `derived_obj` 内存布局中属于 `Base` 的那一部分** 。既然直接指向了原对象，当然可以直接修改，不需要 `const` 限制。 *** ** * ** *** ### 4.3）对象切片 ```cpp void test_object_slicing() { Derived d; d.base_data = 100; d.derived_data = 200; // ⚠️ 发生对象切片！这里调用的是 Base::Base(const Base& other) Base b = d; cout << b.base_data << endl; // 输出 100，基类数据被成功拷贝 // cout << b.derived_data << endl; // ❌ 编译报错！b 对象里根本没有 derived_data } ``` **按值赋值** * `Base b = d;`迫使编译器调用`Base`的拷贝构造函数 * 而`Base`的拷贝构造函数只认识`Base`自己的成员变量（`base_data`） * 它对 `Derived` 特有的 `derived_data` 视而不见 *** ** * ** *** ### 4.4）基类绝对不能赋值给派生类 ```cpp void test_base_to_derived_assignment() { Base b; // Derived d = b; // ❌ 编译直接报错！不允许这种操作！ } ``` *** ** * ** *** ### 4.5）向下转型的安全隐患与 RTTI * **披着 `Base` 外衣的 `Derived`** ```cpp Base* true_derived = new Derived(); ``` * **纯正的`Base`** ```cpp Base* pure_base = new Base(); ``` *** ** * ** *** #### 1）强制类型转换（极其危险） ```cpp Derived* p1 = (Derived*)pure_base; ``` **`p1->derived_data = 10;`** ------------\>编译通过，但运行时极其容易错误，**因为内存里根本没有`derived_data`** #### 2）安全的向下转型（dynamic_cast 安全转换） ```cpp Derived* unsafe_ptr = dynamic_cast(pure_base); if (unsafe_ptr == nullptr) { cout << "转换失败！被 RTTI 拦截，安全着陆。" << endl; } ``` `pure_base`本体就是个 `Base` #### 总结 当使用 `dynamic_cast` 时，`C++` 运行时系统会去查询对象虚函数表`（vtable）`旁的 `type_info` 信息（这就是 `RTTI`） *** ** * ** *** ## 5. 继承中的作用域 ### 5.1）基类和派生类都有独立的作用域 在 `C++` 编译器的眼里，全局作用域是最外层，基类作用域在里面，派生类作用域在最里面 **编译器找名字的顺序：先在 领地 B 找 -\> 找不到再去 领地 A 找 -\> 再找不到去全局找** ```cpp class Base { // 领地 A：Base 的作用域 }; class Derived : public Base { // 领地 B：Derived 的作用域 }; ``` *** ** * ** *** ### 5.2）同名成员的"隐藏"与 基类:: 显式访问 **因为编译器找名字是从内向外找（先找派生类，再找基类）** 一旦在派生类的作用域里找到了你要的名字，它就会立刻停止搜索。 这就导致基类里那个同名的成员被"屏蔽"了 ```cpp #include using namespace std; class Base { public: int value = 100; // 基类的 value }; class Derived : public Base { public: int value = 200; // 派生类的 value，名字相同，触发隐藏！ void print() { // 1. 直接访问，编译器在当前作用域找到了 value，直接用 cout << "直接访问 value: " << value << endl; // 输出 200 // 2. 破除隐藏：必须加上域作用限定符 Base:: cout << "显式访问 Base::value: " << Base::value << endl; // 输出 100 } }; ``` *** ** * ** *** ### 5.3）基类与派生类中关于 函数重载 的潜规则 由于基类和派生类是两个独立的作用域，所以在派生类中只要写了一个同名函数，不管参数列表是什么，基类中所有的同名函数都会被瞬间"秒杀"（隐藏），对派生类对象不再直接可见 * 我们先定义一个基类 ```cpp class Base { public: void func() { cout << "Base 的无参 func()" << endl; } void func(int x) { cout << "Base 的带参 func(int)" << endl; } }; ``` * 再定义一个派生类 ```cpp class Derived : public Base { public: // 只要名字叫 func，基类里的所有 func 统统被屏蔽！ void func(string s) { cout << "Derived 的 func(string)" << endl; } }; ``` * 接着我们测试 ```cpp void test_function_hiding() { Derived d; ``` ❌ 编译报错！找不到无参的 func，因为被隐藏了 ```cpp d.func(); ``` ❌ 编译报错！找不到接受 int 的 func，即使你传了 10，它也只认 string 版本的 ```cpp d.func(10); ``` ✅ 成功调用 Derived 的版本 ```cpp d.func("hello"); ``` **破除隐藏的唯一方法：指名道姓** ```cpp d.Base::func(); d.Base::func(10); ``` *** ** * ** *** ## 6. 派生类的默认成员函数 默认成员函数通常会有6个 **但是我们通常只关注前四个：构造函数、析构函数、拷贝构造函数、赋值重载** *** ** * ** *** ### 6.1）❗我们写这几个默认成员函数，首先思考几个原则性的问题 1. 我们不写，默认生成的函数行为是什么？是否符合要求？ 2. 不符合，我们要自己实现吗？如何实现？ > **问题1：** > > * **默认行为（编译器的铁律）**：编译器为你生成的默认函数，对待这两部分有不同的策略。 > * **对待基类部分**：无条件调用基类对应的默认函数（默认构造、默认析构、拷贝构造函数、赋值重载）。 > * **对待派生类自己的成员** ： > * 对于内置类型（`int`，指针，`char` 等）：构造时不初始化（随机值）；拷贝/赋值时进行无脑的字节拷贝（**浅拷贝**）；析构时不作任何处理。 > * 对于自定义类型（如 `std::string`）：调用它们自己的默认函数。 > * **是否符合要求？（分水岭）** > * **符合** ：如果你的派生类里只有普通的 `int`，或者像 `std::string` 这种自己会管理内存的智能对象，编译器的默认行为堪称完美，你千万不要自己手写。 > * **不符合（灾难降临）** ：如果你的派生类里有**裸指针** ，并且在堆区 `new` 了一块内存（比如 `int* arr = new int[100]`）。默认的"浅拷贝"会让两个对象的指针指向同一块内存，析构时会导致 **Double Free** （重复释放内存）导致程序直接崩溃 > > **问题2** > > * **结论** ：必须自己实现（遵守 C++ 的 **Rule of Three / Rule of Five**：析构、拷贝构造、赋值重载，要写就一起写）。 > * **如何实现的"生死线"** ：在你自己手写派生类的这些函数时，你必须**显式地**去处理"基类部分"！如果你忘了，编译器绝不会帮你填坑，它会给你塞一个默认的过去，导致极其隐蔽的 Bug。 *** ** * ** *** ### 6.2）代码级剖析 假设我们有这样一个场景：**基类 `Person`，派生类 `Student`** ```cpp #include #include using namespace std; class Person { protected: int m_age; public: Person(int age = 0) : m_age(age) { cout << "Person 构造" << endl; } Person(const Person& p) : m_age(p.m_age) { cout << "Person 拷贝构造" << endl; } Person& operator=(const Person& p) { if (this != &p) m_age = p.m_age; cout << "Person 赋值" << endl; return *this; } virtual ~Person() { cout << "Person 析构" << endl; } }; ``` *** ** * ** *** **接下来，我们手撕`Student`的四大默认函数** 1. 派生类的构造函数（先造老子，再造儿子） * 如何实现： 必须在派生类的初始化列表中，显式调用基类的构造函数来初始化基类部分 **如果你不写，编译器会强行调用基类的无参默认构造函数（如果基类没有无参构造，直接编译报错）** ```cpp class Student : public Person { private: char* m_name; public: // ✅ 正确姿势：通过初始化列表，把 age 传给 Person，同时初始化自己的 m_name Student(int age, const char* name) : Person(age) { m_name = new char[strlen(name) + 1]; strcpy(m_name, name); cout << "Student 构造" << endl; } }; ``` *** ** * ** *** 2. 派生类的拷贝构造函数 * **如何实现：** 很多人自己写深拷贝时，光顾着拷贝自己的指针，忘了基类！ 如果你不显式调用基类的拷贝构造，**编译器会去调用基类的默认无参构造函数！导致你新对象的 `m_age` 变成了 `0` 或者`随机值`** ❌ 错误姿势：忘了基类！导致 Person 部分被默认初始化，产生数据切片 ```cpp Student(const Student& other) { ... } ``` ✅ 正确姿势：必须在初始化列表中显式调用 `Person` 的拷贝构造，传入 `other!` 💡 魔法点：这里把 Student 引用传给 Person 的引用参数，发生了我们之前讲过的"绝对安全"的向上转型！ ```cpp Student(const Student& other) : Person(other) { // 自己动手做深拷贝 m_name = new char[strlen(other.m_name) + 1]; strcpy(m_name, other.m_name); cout << "Student 拷贝构造" << endl; } ``` *** ** * ** *** 3. 派生类的赋值运算符重载 * 如何实现： 赋值重载同样需要处理两层逻辑 * 一要**防止自己赋值给自己** * 二要**显式调用基类的赋值重载，最后再处理自己的深拷贝** ```cpp // ✅ 正确姿势 Student& operator=(const Student& other) { cout << "Student 赋值" << endl; // 1. 防身术：防止自己赋值给自己（极度危险，会导致自己的内存先被删掉） if (this == &other) { return *this; } // 2. 显式调用基类的赋值重载，处理基类部分的数据（age） // 💡 魔法点：显式指明作用域 Person::operator=(other); // 3. 处理派生类自己的深拷贝（先释放旧的，再分配新的） delete[] m_name; m_name = new char[strlen(other.m_name) + 1]; strcpy(m_name, other.m_name); return *this; } ``` *** ** * ** *** 4. 派生类的析构函数 * **如何实现：** 在析构函数里，你只需要打扫派生类自己弄脏的屋子（释放 `m_name`）。绝对不要去显式调用 `~Person()` * **底层机制：** 编译器在执行完派生类的析构函数体后，会自动在底层插入对基类析构函数的调用。这就保证了**先灭儿子，再灭老子**的绝对顺序。如果你手贱调用了，会导致基类被析构两次 ```cpp // ✅ 正确姿势：只管好自己，剩下的交给编译器 ~Student() { // 记得基类的析构函数一定要是 virtual 的！ delete[] m_name; cout << "Student 析构" << endl; // 编译器会自动在这里偷偷加上：Person::~Person(); } ``` *** ** * ** *** ### 6.3）图表解析 **构造时先造老子后造儿子，析构时先灭儿子后灭老子**  *** ** * ** *** ## 7. 实现一个不能被继承的类 ### 方法 1：利用构造函数的私有性（C++98 时代的"黑科技"） **派生类的构造函数必须调用基类的构造函数** 如果你把基类的构造函数设为 `private`，那么派生类在实例化时，就会因为"看不见、调不动"父类的构造函数而导致编译报错 ```cpp class Base { private: Base() {} // 1. 构造函数私有化：只有我自己能用，别人（包括儿子）都调不到 }; class Derived : public Base { public: // ❌ 编译报错：'Base::Base()' is private // 因为 Derived 的构造函数必须先调用 Base 的构造函数，但 Base 把它藏起来了 Derived() {} }; int main() { // Base b; // ❌ 连基类自己也没法直接在外部实例化了 // Derived d; // ❌ 派生类彻底废了 return 0; } ``` *** ** * ** *** ### 方法 2：使用 final 关键字（C++11 现代标准，最推荐） `C++11` 引入了`final`关键字，直接从语法层面封死了继承的路 **在类名后面直接加 final** ```cpp // 在类名后面直接加 final class Base final { public: Base() {} }; // ❌ 编译报错：cannot derive from 'final' base 'Base' in derived type 'Derived' class Derived : public Base { }; ``` *** ** * ** *** ## 8. 继承与友元 友元关系不能继承，也就是说**基类友元不能访问派生类私有和保护成员** > 通俗地说："**你父亲的朋友（基类的友元），不一定是你的朋友（派生类的友元）** 。"即便 `Display` 函数在 `Person` 里被声明为友元，它也只能看到 `Student` 对象中属于 `Person` 的那部分，而看不到 `Student` 自己特有的保护成员 ```cpp class Student; 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; // 编译报错：无法访问 protected 成员 } int main() { Person p; Student s; // 编译报错: error C2248: "Student::_stuNum": 无法访问 protected 成员 // 解决方案: Display 也要成为 Student 的友元即可 Display(p, s); return 0; } ``` 1. `Display` 是 `Person` 的友元 → 它可以访问 `Person` 的 `_name` 2. `Student` 继承自 `Person` 3. `Display` 试图访问 `Student` 特有的 `_stuNum` 4. **结局：编译器拒绝** 因为 `Display` 并没有在 `Student` 类里获得"好友位"。 *** ** * ** *** ## 9. 继承与静态成员 基类定义了 `static` 静态成员，则整个继承体系里面**只有一个** 这样的成员。无论派生出多少个派生类，都只有一个 `static` 成员实例 ```cpp class Person { public: string _name; static int _count; }; int Person::_count = 0; class Student : public Person { protected: int _stuNum; public: 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; } }; ``` *** ** * ** *** ## ⭕10. 单继承、多继承 及其 菱形继承问题 ### 10.1）单继承 一个派生类只从一个基类继承 ```cpp class Animal { public: void eat() { cout << "正在进食..." << endl; } }; class Dog : public Animal { public: void bark() { cout << "汪汪汪！" << endl; } }; ``` **内存模型** * **布局：** 内存中先排布 `Animal` 的成员，紧接着排布 `Dog` 的成员 * **关系：** 是一条直线：Animal -\> Dog *** ** * ** *** ### 10.2）多继承 多继承允许一个派生类同时从两个或多个基类继承 ```cpp //基类 A：沙发 class Sofa { public: void sit() { cout << "坐着很舒服..." << endl; } }; //基类 B：床 class Bed { public: void sleep() { cout << "躺着很安稳..." << endl; } }; //派生类：沙发床 class SofaBed : public Sofa, public Bed { public: void fold() { cout << "正在折叠成沙发..." << endl; } }; ``` **内存模型** * **布局** ：内存中会按照继承声明的顺序，先排布 `Sofa` 的成员，再排布 `Bed` 的成员，最后是 `SofaBed` 自己的成员。 * **关系** ：是一个多对一的结构： `{Sofa, Bed} -> SofaBed` *** ** * ** *** ### 10.3）菱形继承问题 **菱形继承** ：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有**数据冗余** 和**二义性** 的问题，在 `Assistant` 的对象中 `Person` 成员会有两份  *** ** * ** *** ### 10.4）虚继承 `C++`语法复杂，多继承就是一个体现。 有了多继承，就存在菱形继承； 有了菱形继承就会有菱形虚拟继承 **我们观察下面的代码** ```cpp class Person { public: string _name; // 姓名 /*int _tel; int _age; string _gender; string _address;*/ }; //使用虚继承 Person 类 class Student : virtual public Person { protected: int _num; // 学号 }; //使用虚继承 Person 类 class Teacher : virtual public Person { protected: int _id; // 职工编号 }; //教授助理 class Assistant : public Student, public Teacher { protected: string _majorCourse; // 主修课程 }; int main() { //使用虚继承，可以解决数据冗余和二义性 Assistant a; a._name = "peter"; return 0; } ``` **`virtual` 必须加在产生"分叉"的地方，而不是"汇合"的地方** *** ** * ** *** ### 10.5）多继承中的指针偏移问题 ```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; } ``` | 指针变量 | 指向类型 | 实际地址值 | 说明 | |------|-----------|---------|----------------------------| | `p3` | `Derive*` | `0x100` | 指向对象开头 | | `p1` | `Base1*` | `0x100` | 因为 `Base1` 在开头，所以和 `p3` 相等 | | `p2` | `Base2*` | `0x104` | 发生了偏移！跳过了 `Base1` 的空间 | *** ** * ** *** ## 11. 继承与组合 **继承是 `is-a` 关系** **组合是 `has-a` 关系** ```cpp class Engine { public: void start() { /* 引擎启动逻辑 */ } }; class Car { private: Engine _eng; // 组合：引擎是 Car 的一个成员 public: void run() { _eng.start(); // ✅ 黑箱复用：Car 只管用 Engine 的公开接口，不关心其内部怎么喷油的 cout << "汽车行驶中..." << endl; } }; ``` `Engine` 内部怎么改，只要 `start()` 接口不变，`Car` 就不受影响。每个类都保持了良好的封装性 *** ** * ** *** ### 为什么优先使用组合（Has-A）？ * **组合** ：宿主类只知道成员类的 `public` 接口。成员类内部怎么改（甚至改了成员变量名），只要接口不变，宿主类代码一行都不用动。 * **继承** ：派生类可以看到基类的 `protected` 成员。基类一旦改动内部逻辑，往往会引发派生类的连锁崩溃。这被称为\*\*"脆弱的基类问题"\*\* *** ** * ** *** ### 什么时候必须用继承 C++ 的灵魂------**多态**，必须依赖继承 | 场景需求 | 推荐方案 | 理由 | |-----------------|--------|----------------------------| | 我想借用另一个类的功能代码 | **组合** | 借用工具而已，没必要认爹，保持代码独立性。 | | 我想在运行时更换某个组件 | **组合** | 插件式设计，极其灵活。 | | 我需要实现接口的一致性（多态） | **继承** | 只有继承能让你在父类指针下操作不同子类。 | | 两个类有严格的层级和分类关系 | **继承** | 符合人类直觉，逻辑清晰。 | | 我想隐藏基类的复杂实现细节 | **组合** | 继承会暴露太多 `protected` 内容给子类。 | *** ** * ** *** ## 💻结尾--- 核心连接协议 **警告：** 🌠🌠正在接入底层技术矩阵。如果你已成功破解学习中的逻辑断层，请执行以下指令序列以同步数据：🌠🌠 *** ** * ** *** **【📡】 建立深度链接：** **关注**本终端。在赛博丛林中深耕底层架构，从原始代码到进阶协议，同步见证每一次系统升级。 **【⚡】 能量过载分发：** 执行**点赞**操作。通过高带宽分发，让优质模组在信息流中高亮显示，赋予知识跨维度的传播力。 **【💾】 离线缓存核心：** 将本页加入**收藏**。把这些高频实战逻辑存入你的离线存储器，在遭遇系统崩溃或需要离线检索时，实现瞬时读取。 **【💬】 协议加密解密：** 在**评论区**留下你的散列码。分享你曾遭遇的代码冲突或系统漏洞（那些年踩过的坑），通过交互式编译共同绕过技术陷阱。 **【🛰️】 信号频率投票：** 通过**投票**发射你的选择。你的每一次点击都在重新定义矩阵的进化方向，决定下一个被全量拆解的技术节点。 *** ** * ** ***