一、前言：为什么继承和多态是C++灵魂？
我们吃透了C++语法、内存模型、深浅拷贝、类四大默认函数、STL全套，已经掌握了单一类的开发能力。
但真正的工程开发、框架设计、大型项目架构，绝对不会只写独立类，而是依靠继承 + 多态实现代码复用、层级管理、接口统一、动态扩展。
封装、继承、多态是面向对象三大核心特性：
封装：权限控制、数据隐藏、安全隔离（前面已学完）
继承：代码复用、层级派生、纵向扩展
多态：接口统一、动态绑定、灵活扩展
可以说：不懂继承多态，就完全不懂面向对象，看不懂源码、写不了框架、过不了面试。
一次性彻底打通继承与多态全部重难点，覆盖基础语法、底层原理、经典坑点、菱形继承、虚函数、抽象类、面试真题，完结C++面向对象全部体系！
二、继承核心概念与三大继承权限
2.1 继承是什么？
继承是C++实现代码复用的核心机制。定义一个通用父类（基类），子类（派生类）直接拥有父类所有可继承成员，无需重复编写代码。
父类：通用、抽象、公共代码
子类：特有、扩展、个性化代码
2.2 三大继承方式（面试高频背诵）
C++支持public / protected / private三种继承方式，决定父类成员在子类中的访问权限。
继承方式 | 父类public成员 | 父类protected成员 | 父类private成员 | 工程使用场景 |
|---|---|---|---|---|
public 公有继承 | public | protected | 不可继承 | 日常开发、99%场景 |
protected 保护继承 | protected | protected | 不可继承 | 框架内部层级封装 |
private 私有继承 | private | private | 不可继承 | 极少用，几乎不用 |
2.3 核心结论（必背）
1.父类private私有成员，永远不可被继承；
2. 公有继承不改变权限、保护和私有继承会收拢权限；
3.工程开发只使用 public 继承，其余两种基本不用。
三、子类父类成员访问规则、成员隐蔽问题
3.1 访问权限总规则
1. public：类内、类外、子类全部可访问
2. protected：类内、子类可访问，外部不可访问
3. private：仅本类内部可访问，子类、外部均不可访问
3.2 成员隐蔽（同名覆盖）
当子类和父类存在同名成员变量/普通成员函数时，子类成员会隐蔽父类成员。
直接访问默认调用子类，加作用域父类名::可强制访问父类成员。
#include <iostream> using namespace std; class Father { public: int age = 40; }; class Son : public Father { public: int age = 18; }; int main() { Son s; cout << s.age << endl; // 18 子类隐蔽父类 cout << s.Father::age << endl; // 40 强制访问父类 return 0; }注意：普通函数是隐蔽，虚函数是重写，二者完全不同！
四、继承中构造与析构执行顺序（面试必考）
这是面试最常问、笔试最爱考的基础题，必须精准记忆！
4.1 构造函数执行顺序
先父后子：父类构造 → 子类构造
原理：子类依赖父类资源，必须先初始化父类部分成员，再初始化子类独有成员。
4.2 析构函数执行顺序
先子后父：子类析构 → 父类析构
原理：先销毁子类扩展资源，再销毁父类基础资源，和构造顺序完全相反。
4.3 代码验证
#include <iostream> using namespace std; class Father { public: Father(){ cout << "父类构造" << endl; } ~Father(){ cout << "父类析构" << endl; } }; class Son : public Father { public: Son(){ cout << "子类构造" << endl; } ~Son(){ cout << "子类析构" << endl; } }; int main() { Son s; return 0; } // 输出顺序：父构造→子构造→子析构→父析构五、多继承优缺点与菱形继承致命问题
5.1 多继承概念
C++支持一个子类同时继承多个父类，这是Java/Python没有的特性，也是C++复杂点所在。
优势：最大限度复用多类代码、实现多维度特性组合
弊端：层级混乱、耦合度高、极易出现菱形继承问题
5.2 菱形继承（钻石继承）致命BUG
场景：两个子类继承同一个父类，再由一个新类同时继承这两个子类，形成菱形结构。
带来两大致命问题：
1.数据冗余：顶层父类成员会被继承多份，重复存储
2.二义性问题：访问顶层父类成员编译器不知道调用哪一份
class Animal { public: int age; }; class Dog : public Animal{}; class Cat : public Animal{}; // 菱形继承 class AnimalSon : public Dog, public Cat{}; int main() { AnimalSon as; // 报错！二义性，不知道是Dog的age还是Cat的age // as.age = 10; return 0; }六、虚继承彻底解决菱形继承问题
6.1 解决方案：virtual 虚继承
通过virtual 虚继承，让顶层父类只保留唯一一份成员数据，彻底解决冗余和二义性。
6.2 虚继承修正代码（标准写法）
class Animal { public: int age; }; // 虚继承：公共父类只保留一份 class Dog : virtual public Animal{}; class Cat : virtual public Animal{}; class AnimalSon : public Dog, public Cat{}; int main() { AnimalSon as; as.age = 10; // 无歧义、无冗余 return 0; }6.3 底层原理
虚继承不会拷贝父类数据副本，而是通过虚基类指针指向唯一的公共父类数据，保证全局唯一，彻底解决菱形继承问题。
七、多态核心原理、虚函数底层机制
多态是面向对象最高级、最重要的特性。
7.1 多态定义
同一接口，不同实现。父类指针/引用指向子类对象，调用同一个函数，执行不同的子类逻辑。
7.2 多态实现四大条件（面试必背）
1. 必须存在继承关系
2. 父类函数必须为virtual 虚函数
3. 子类重写父类虚函数（函数名、参数、返回值完全一致）
4. 父类指针/引用指向子类对象
7.3 多态实战代码
#include <iostream> using namespace std; class Animal { public: // 虚函数 virtual void speak() { cout << "动物在叫" << endl; } }; class Dog : public Animal { public: // 重写虚函数 void speak() override { cout << "汪汪汪" << endl; } }; class Cat : public Animal { public: void speak() override { cout << "喵喵喵" << endl; } }; int main() { // 父类指针指向子类对象，实现多态 Animal* a1 = new Dog; Animal* a2 = new Cat; a1->speak(); // 汪汪汪 a2->speak(); // 喵喵喵 delete a1; delete a2; return 0; }7.4 底层原理：虚函数表 vtable
1. 包含虚函数的类，底层拥有一张虚函数表，存储虚函数地址；
2. 对象内部含有虚表指针 vptr，指向本类虚表；
3. 多态调用时，通过虚表指针动态查找函数地址，运行时绑定；
4. 普通函数编译时绑定，虚函数运行时绑定，实现动态多态。
八、重载与重写（覆盖）本质区别
90%面试者分不清重载和重写，本表直接满分通关！
对比维度 | 重载 Overload | 重写 Override（覆盖） |
|---|---|---|
作用范围 | 同一个类内部 | 父子类继承关系中 |
函数特征 | 函数名相同，参数列表不同 | 函数名、参数、返回值完全一致 |
virtual | 不需要虚函数 | 必须是虚函数 |
绑定时机 | 编译时静态绑定 | 运行时动态绑定（多态） |
核心作用 | 同名函数适配多组参数 | 子类改写父类接口，实现多态 |
关键字拓展：override 显式重写，强制编译器检查是否合法重写，工程开发推荐全部加上！
九、纯虚函数与抽象类、接口思想
9.1 纯虚函数语法
virtual 函数返回值 函数名() = 0;
9.2 抽象类特性（必考）
1. 包含纯虚函数的类称为抽象类；
2.抽象类无法实例化对象；
3. 子类必须全部重写纯虚函数，否则子类也是抽象类；
4. 抽象类主要用于定义统一接口规范，不做具体实现。
9.3 抽象类实战接口编程
#include <iostream> using namespace std; // 抽象接口类 class USB { public: // 纯虚函数：统一接口规范 virtual void work() = 0; }; class UDisk : public USB { public: // 必须重写 void work() override { cout << "U盘传输数据" << endl; } }; class Mouse : public USB { public: void work() override { cout << "鼠标控制光标" << endl; } }; int main() { USB* u1 = new UDisk; USB* u2 = new Mouse; u1->work(); u2->work(); return 0; }这就是工程中接口编程、依赖抽象不依赖具体的核心思想！
十、继承多态高频工程踩坑合集
坑1：父类析构不写virtual，内存泄漏
父类指针指向子类对象，delete释放时只会调用父类析构，子类资源无法释放，造成严重内存泄漏。多态场景父类析构必须加virtual！
坑2：混淆重载和重写，多态失效
参数列表不一致、缺少virtual、未重写完全，都会导致多态无法触发，依旧调用父类函数。
坑3：菱形继承不使用虚继承
数据冗余、成员访问二义性，编译报错、程序逻辑混乱。
坑4：抽象类尝试实例化对象
包含纯虚函数的类无法创建对象，只能作为父类指针指向子类。
坑5：构造函数调用虚函数，多态失效
构造阶段子类未初始化完成，虚函数会被静态绑定，无法实现多态。
十一、大厂面试满分问答
Q1：继承中构造和析构的执行顺序？为什么？
构造顺序为先父后子，先初始化父类基础成员，再初始化子类扩展成员；析构顺序为先子后父，先释放子类独有资源，再释放父类公共资源，保证资源依赖安全、层级有序。
Q2：C++多态的实现原理和必要条件？
多态基于虚函数和虚函数表实现。满足四个条件：存在继承关系、父类声明虚函数、子类重写虚函数、父类指针或引用指向子类对象。程序运行时通过虚表指针动态查找对应子类函数地址，实现动态绑定多态。
Q3：重载和重写的区别？
重载发生在同类内部，函数名相同参数不同，编译时静态绑定，用于扩展同名函数参数适配；重写发生在父子继承关系中，虚函数完全复刻重写，运行时动态绑定，是多态的核心实现方式。
Q4：抽象类的作用是什么？可以实例化吗？
包含纯虚函数的类为抽象类，无法实例化对象。核心作用是定义统一的接口规范，强制子类实现指定方法，实现接口统一、代码解耦、多态扩展，是工程接口编程的基础。
Q5：什么是菱形继承？如何解决？
多个子类继承同一父类，再被同一子类多继承，形成菱形结构，会造成顶层父类数据冗余、访问二义性问题。通过virtual虚继承，让顶层父类数据全局唯一，彻底解决菱形继承缺陷。
十二、今日总结
彻底通关C++继承与多态全套体系，完结面向对象三大特性：
✅ 三大继承方式、权限规则、工程使用规范
✅ 继承构造析构执行顺序、底层依赖逻辑
✅ 多继承优缺点、菱形继承BUG根源
✅ 虚继承原理、彻底解决菱形继承问题
✅ 多态四大条件、虚函数表底层机制
✅ 重载与重写核心区别、面试满分区分
✅ 纯虚函数、抽象类、接口编程思想
✅ 继承多态高频踩坑、内存泄漏避坑方案
至此，C++面向对象封装、继承、多态全部学完，底层原理全覆盖，完全具备框架级代码理解能力！
