当前位置：首页 > news >正文

C++：多态详解（从概念本质、语法规则到底层实现，结合实战代码的全方位指南）

news 2026/5/12 7:45:08

一. 多态的概念：从“多种形态说起”

1.1 多态的概念解析

多态通俗来说就是“多种形态”，在C++中分为两类

编译时多态(静态多态)：通过函数模板，重载来实现，编译阶段确定调用的函数(如add(1,2)和add(1,2,3,4)调用的不同的函数)
运行时多态(动态多态)：本篇博客核心讲解的地方，通过”基类指针/引用 + 虚函数重写“，运行阶段根据指向的对象的类型确定调用的函数

#include <iostream> using namespace std;

// 基类：Person class Person { public: // 虚函数：标记为需要参与多态 virtual void BuyTicket() { cout << "买票-全价" << endl; } };

2.2 条件 2：虚函数的重写（覆盖）

派生类中定义一个 “与基类虚函数完全一致” 的函数，即为重写。这里 “完全一致” 指：

函数名相同；
参数列表（参数类型、个数、顺序）相同（缺省参数可以不管）；
返回值类型相同（协变除外，下文讲解）。

代码示例（注意看注释）：

// 基类：Person class Person { public: // 虚函数：标记为需要参与多态 virtual void BuyTicket() { cout << "买票-全价" << endl; } }; // 派生类：Student（继承Person） class Student : public Person { public: // 重写基类虚函数：函数名、参数、返回值完全一致 // 派生类中virtual也可以省略 virtual void BuyTicket() { cout << "买票-打折" << endl; } }; // 派生类：Soldier（继承Person） class Soldier : public Person { public: // 重写基类虚函数 // 派生类中virtual也可以省略 virtual void BuyTicket() { cout << "买票-优先" << endl; } }; // 关键：用基类指针调用虚函数（满足多态条件1） // 这里也可以用基类引用 void Func(Person* ptr) { // 运行时根据ptr指向的对象类型，调用对应类的BuyTicket // Person* ptr ptr->BuyTicket(); // 如果是基类引用(Person& ptr) //ptr.BuyTicket(); } int main() { Person ps; // 基类对象 Student st; // 派生类对象（学生） Soldier sr; // 派生类对象（军人） Func(&ps); // 指向基类对象 → 调用Person::BuyTicket → 输出“买票-全价” Func(&st); // 指向学生对象 → 调用Student::BuyTicket → 输出“买票-打折” Func(&sr); // 指向军人对象 → 调用Soldier::BuyTicket → 输出“买票-优先” return 0; }

注意：派生类重写时，即使不加virtual，也能构成重写（因为基类虚函数的 “虚属性” 会被继承），但不建议这么写，可读性差且易出错。

坑点（下面的笔试题会有体现）：在 C++ 中，虚函数重写时若基类和派生类的虚函数都指定了缺省参数，调用时的缺省值只由“基类的函数声明”决定，与派生类的重写实现无关。

2.3 多态场景的一个笔试选择题（重要）：

以下程序输出的结果是什么（B）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

class A { public: virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; } virtual void test() { func(); } }; class B : public A { public: void func(int val = 0) { std::cout << "B->" << val << std::endl; } }; int main(int argc, char* argv[]) { B* p = new B; p->test(); return 0; }

图解如下：

改编扩展：以下程序输出的结果是什么（D）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

class A { public: virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; } virtual void test() { func(); } }; class B : public A { public: void func(int val = 0) { std::cout << "B->" << val << std::endl; } }; int main(int argc, char* argv[]) { B* q = new B; q->func(); return 0; }

图解如下：

三、虚函数重写的特殊情况

虚函数重写并非只有 “完全一致” 一种情况，还有两种特殊场景需要注意：协变和析构函数重写，这也是面试高频考点。

3.1 协变（了解）

派生类重写基类虚函数时，返回值类型可以不同，但必须满足：

基类虚函数返回 “基类对象的指针 / 引用”；
派生类虚函数返回 “派生类对象的指针 / 引用”。

这种情况称为“协变”，实际开发中使用较少，了解即可。

代码示例（注意看注释）：

#include <iostream> using namespace std; // 基类A class A {}; // 派生类B（继承A） class B : public A {}; // 基类Person class Person { public: // 虚函数：返回基类A的指针 virtual A* BuyTicket() { cout << "买票-全价" << endl; return nullptr; } }; // 派生类Student class Student : public Person { public: // 重写：返回派生类B的指针（协变） virtual B* BuyTicket() { cout << "买票-打折" << endl; return nullptr; } }; void Func(Person* ptr) { ptr->BuyTicket(); // 多态调用依然生效 } int main() { Person ps; Student st; Func(&ps); // 输出“买票-全价” Func(&st); // 输出“买票-打折” return 0; }

3.2 析构函数的重写（重点）

基类的析构函数为虚函数：基类析构函数加virtual后，派生类析构函数无论是否加virtual，都构成重写。这是因为编译器会将所有析构函数的名称统一处理为destructor，看似名称不同，实则一致。

注意：这个在面试题中经常考到，问基类中的析构函数建不建议写成虚函数？大家可以结合下面的代码示例和为什么去进行回答，这样才能讲清楚

为什么需要析构函数构成重写？
如果基类析构函数不是虚函数，用基类指针指向派生类对象并delete时，只会调用基类析构函数，导致派生类中动态申请的资源无法释放，引发内存泄漏。

代码示例（注意看注释，其中额外测试部分是补充了解的和这里的重点不同）：

class A { public: // 基类析构函数加virtual，支持重写 virtual ~A() { cout << "~A()" << endl; } }; class B : public A { public: // 派生类析构函数：自动构成重写（加不加virtual都可以） ~B() { cout << "~B()->delete:" << _p << endl; delete _p; // 释放派生类动态申请的资源 } protected: int* _p = new int[10]; // 派生类动态申请的数组 }; void test() { cout << "--------额外测试结果--------" << endl; //额外测试，这个是正常场景，加不加都行 //只是为了让大家了解一下这个析构顺序 //析构顺序：~B(),~A(),~A() //其中第一个~A()是因为子类B析构完后调用基类的（先子后父）,后面一个是a对象析构 A a; B b; } // 基类只要保障了析构函数是虚函数，下面场景就不会存在内存泄漏 int main() { // 基类指针指向派生类对象 A* ptr1 = new B; delete ptr1; // 多态调用：先调用~B()，再先子后父自动调用~A()，无内存泄漏 // 基类指针指向基类对象 A* ptr2 = new A; delete ptr2; // 调用~A() test(); return 0; }

主要测试版块：如果基类析构不加virtual：delete ptr1只会调用~A()，B类中_p指向的数组未释放，导致内存泄漏。额外测试那里加不加都行。

四. C++11：override 与 final 关键字

虚函数重写对语法要求严格（如函数名写错、参数类型不匹配），这些错误编译时不会报错，只会在运行时出现非预期结果。C++11 提供override和final两个关键字，帮我们在编译阶段检测错误。

4.1 override：检测是否重写

在派生类虚函数后加override，编译器会检查该函数是否真的重写了基类虚函数。若未重写（如函数名错、参数错），直接编译报错。
代码示例（注意看注释）：

class Car { public: // 基类虚函数：Drive（注意拼写是Drive，不是Dirve） virtual void Drive() { cout << "Car-行驶" << endl; } }; class Benz : public Car { public: // 错误示例：函数名写成Dirve，加override后编译报错 // virtual void Dirve() override { cout << "Benz-舒适" << endl; } // 正确示例：函数名正确，override检测通过 virtual void Drive() override { cout << "Benz-舒适" << endl; } }; int main() { Car* p = new Benz; p->Drive(); // 多态调用：输出“Benz-舒适” return 0; }

4.2 final：禁止重写

在基类虚函数后加final，表示该虚函数不允许任何派生类重写。若派生类强行重写，编译报错。
代码示例（注意看注释）：

class Car { public: // 基类虚函数加final：禁止派生类重写 virtual void Drive() final { cout << "Car-行驶" << endl; } }; class Benz : public Car { public: // 错误：Drive()被final修饰，无法重写，编译报错 // virtual void Drive() override { cout << "Benz-舒适" << endl; } }; int main() { return 0; }

五. 易混淆概念：重载、重写、隐藏的对比(常考)

代码示例（借鉴-注意看注释）：

特性	重载（Overload）	重写（Override）	隐藏（Hide）
作用域	同一类（同一作用域）	基类与派生类（不同作用域）	基类与派生类（不同作用域）
函数名	必须相同	必须相同	必须相同
参数列表	必须不同（类型/个数/顺序）	必须相同	可相同可不同
返回值类型	无要求	必须相同（协变除外）	无要求
虚函数要求	无	必须都是虚函数	无
核心场景	同一类中同名函数的不同实现	多态的核心，动态绑定	派生类屏蔽基类同名成员（非重写）
底层机制	编译期静态绑定，通过参数列表区分函数	运行期动态绑定，依赖虚函数表	编译期静态绑定，通过作用域区分
示例	class A { void func(int); void func(double); }	class A { virtual void func(); }; class B : public A { void func() override; }	class A { void func(); }; class B : public A { void func(int); }
注意事项	仅在同一类中生效，派生类中若与基类函数同名且参数不同，会隐藏基类函数	重写时函数签名（函数名+参数+返回值）必须严格一致，析构函数重写有特殊性	若派生类函数与基类虚函数同名但参数不同，会隐藏基类虚函数，导致多态失效