C++ 多态：面向对象的动态行为核心机制
一、多态的概念与分类
多态是 C++ 面向对象三大特性之一，指同一行为在不同对象上表现出不同的形态，核心是'一个接口，多种实现'。
多态主要分为两大类，二者的实现原理和触发时机截然不同：
- 静态多态：编译阶段确定调用关系，也叫编译时多态，实现方式包括函数重载和运算符重载。
- 动态多态：运行阶段确定调用关系，也叫运行时多态，实现方式是虚函数 + 基类指针/引用。
生活中的多态示例：同样是'动物叫'这个行为，猫的叫声是'喵喵喵'，狗的叫声是'汪汪汪'，不同动物对象表现出不同的行为形态。
二、静态多态：编译时确定的多态性
静态多态的调用关系在编译阶段就已确定，编译器会根据参数列表的差异匹配对应的函数。
2.1 函数重载实现静态多态
这是最常见的静态多态形式，同一作用域内的同名函数，通过参数的类型或数量区分。
#include <iostream>
using namespace std;
// 静态多态：函数重载
void print(int a) { cout << "整数：" << a << endl; }
void print(double b) { cout << "浮点数：" << b << endl; }
void print(string c) { cout << "字符串：" << c << endl; }
int main() {
// 编译阶段确定调用哪个 print 函数
print(10);
print(3.14);
print("C++ Static Polymorphism");
return 0;
}
2.2 运算符重载实现静态多态
通过重载运算符，让自定义类型支持内置运算符的操作，本质也是编译时多态。
#include <iostream>
using namespace std;
class Point {
public:
int x, y;
Point(int x = 0, int y = 0) : x(x), y(y) {}
// 重载 + 运算符，实现点的坐标相加
Point operator+(const Point& p) {
return Point(this->x + p.x, this->y + p.y);
}
};
int main() {
Point p1(1, 2), p2(3, 4);
// 编译阶段确定调用重载的 + 运算符
Point p3 = p1 + p2;
cout << "p3.x = " << p3.x << ", p3.y = " << p3.y << endl;
return 0;
}
三、动态多态：运行时确定的多态性
动态多态是面向对象编程的核心，其关键是虚函数和基类指针/引用指向派生类对象，调用关系在程序运行时才确定。
3.1 动态多态的实现条件
实现动态多态必须同时满足三个条件：
- 存在继承关系，且通常是公有继承。
- 基类中定义虚函数，派生类重写该虚函数。
- 使用基类的指针或引用指向派生类对象。
3.2 虚函数的定义与使用
虚函数的定义语法是在基类的成员函数前加 virtual 关键字，派生类重写时可以省略 virtual，但建议保留以增强可读性。
3.2.1 基础案例：动物叫的多态实现
#include <iostream>
#include <string>
using namespace std;
// 基类：动物
class Animal {
public:
// 虚函数：动物叫
virtual void bark() { cout << "动物发出叫声" << endl; }
};
// 派生类：猫
class Cat : public Animal {
public:
// 重写基类的虚函数
void bark() override {
// override 关键字显式声明重写，建议添加
cout << "猫：喵喵喵" << endl;
}
};
// 派生类：狗
class Dog : public Animal {
public:
// 重写基类的虚函数
void bark() override {
cout << "狗：汪汪汪" << endl;
}
};
int main() {
// 基类指针指向派生类对象
Animal *animal1 = new Cat();
Animal *animal2 = new Dog();
// 运行时确定调用哪个类的 bark 函数
animal1->bark(); // 输出猫的叫声
animal2->();
animal1;
animal2;
;
}
3.2.2 运行结果
猫：喵喵喵 狗：汪汪汪
注意事项
override关键字用于显式标记派生类对基类虚函数的重写，编译器会检查重写的合法性，建议添加。- 如果基类指针指向基类对象，则调用基类的虚函数；指向派生类对象，则调用派生类重写的函数。
- 虚函数的重写要求函数名、参数列表、返回值类型完全一致，否则会被视为派生类的新函数，而非重写。
3.3 虚析构函数：解决派生类资源泄漏问题
当基类指针指向派生类对象并通过 delete 释放时，如果基类析构函数不是虚函数，会导致派生类的析构函数无法被调用，从而引发内存泄漏。
解决方案：将基类的析构函数声明为虚析构函数。
3.3.1 问题代码演示（非虚析构）
#include <iostream>
using namespace std;
class Base {
public:
Base() { cout << "Base 构造函数" << endl; }
~Base() { cout << "Base 析构函数" << endl; }
// 非虚析构
};
class Derived : public Base {
public:
Derived() { cout << "Derived 构造函数" << endl; }
~Derived() { cout << "Derived 析构函数" << endl; }
// 无法被调用
};
int main() {
Base *p = new Derived();
delete p; // 仅调用基类析构函数，派生类析构未调用
return 0;
}
3.3.2 运行结果（存在问题）
Base 构造函数 Derived 构造函数 Base 析构函数
3.3.3 解决代码（虚析构函数）
#include <iostream>
using namespace std;
class Base {
public:
Base() { cout << "Base 构造函数" << endl; }
virtual ~Base() { cout << "Base 析构函数" << endl; }
// 虚析构函数
};
class Derived : public Base {
public:
Derived() { cout << "Derived 构造函数" << endl; }
~Derived() override { cout << "Derived 析构函数" << endl; }
// 重写虚析构
};
int main() {
Base *p = new Derived();
delete p; // 先调用派生类析构，再调用基类析构
return 0;
}
3.3.4 运行结果（正确释放）
Base 构造函数 Derived 构造函数 Derived 析构函数 Base 析构函数
四、纯虚函数与抽象类
纯虚函数是没有函数体的虚函数，包含纯虚函数的类称为抽象类，抽象类无法实例化对象，只能作为基类被继承。
4.1 纯虚函数的定义语法
virtual 返回值类型 函数名 (参数列表) = 0;
4.2 抽象类的特性
- 抽象类不能创建对象，只能定义指针或引用。
- 派生类必须重写抽象类的所有纯虚函数，否则派生类也会成为抽象类。
- 抽象类的核心作用是定义接口规范，强制派生类实现具体功能。
4.3 代码演示：图形面积计算的抽象类
#include <iostream>
using namespace std;
// 抽象类：图形
class Shape {
public:
// 纯虚函数：计算面积
virtual double getArea() = 0;
// 纯虚函数：计算周长
virtual double getPerimeter() = 0;
};
// 派生类：矩形
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h) : width(w), height(h) {}
// 必须重写所有纯虚函数
double getArea() override { return width * height; }
double getPerimeter() override { return 2 * (width + height); }
};
// 派生类：圆形
class Circle : public Shape {
private:
double radius;
const double PI = ;
:
( r) : (r) {}
{ PI * radius * radius; }
{ * PI * radius; }
};
{
cout << << shape->() << endl;
cout << << shape->() << endl;
}
{
Shape *rect = (, );
Shape *circle = ();
cout << << endl;
(rect);
cout << << endl;
cout << << endl;
(circle);
rect;
circle;
;
}
4.4 运行结果
矩形信息： 面积：15 周长：16 ---------------- 圆形信息： 面积：50.2655 周长：25.1327
五、多态的实战案例：计算器的动态扩展
需求：设计一个支持多种运算的计算器，利用多态特性，让计算器可以动态扩展新的运算类型，无需修改原有代码（符合开闭原则）。
5.1 需求分析
- 定义抽象基类
Operation，包含纯虚函数calculate，用于计算结果。 - 派生类分别实现加法
Add、减法Sub、乘法Mul、除法Div。 - 设计计算器类
Calculator，接收Operation指针，调用计算方法。 - 新增运算类型时，只需新增派生类，无需修改计算器核心代码。
5.2 完整代码实现
#include <iostream>
#include <stdexcept>
using namespace std;
// 抽象基类：运算
class Operation {
public:
double num1, num2;
void setNum(double n1, double n2) { num1 = n1; num2 = n2; }
// 纯虚函数：计算
virtual double calculate() = 0;
};
// 加法运算
class Add : public Operation {
public:
double calculate() override { return num1 + num2; }
};
// 减法运算
class Sub : public Operation {
public:
double calculate() override { return num1 - num2; }
};
// 乘法运算
class Mul : public Operation {
public:
double calculate() override { num1 * num2; }
};
: Operation {
:
{
(num2 == ) ();
num1 / num2;
}
};
{
:
Operation *op;
:
(Operation *operation) : (operation) {}
{
op->(n1, n2);
op->();
}
~() { op; }
};
{
{
;
cout << << addCalc.(, ) << endl;
;
cout << << subCalc.(, ) << endl;
;
cout << << mulCalc.(, ) << endl;
;
cout << << divCalc.(, ) << endl;
cout << << divCalc.(, ) << endl;
} ( exception& e) {
cout << << e.() << endl;
}
;
}
5.3 运行结果
10 + 5 = 15 10 - 5 = 5 10 * 5 = 50 10 / 5 = 2 错误：除数不能为 0
六、多态的核心原理：虚函数表
C++ 动态多态的底层实现依赖虚函数表（vtable）和虚函数指针（vptr），理解其原理能帮助我们更好地使用多态。
6.1 虚函数表的工作机制
- 当类中包含虚函数时，编译器会为该类生成一个虚函数表，表中存储的是虚函数的地址。
- 每个对象的内存布局中，会有一个隐藏的虚函数指针
vptr，指向所属类的虚函数表。 - 当基类指针指向派生类对象时，
vptr会指向派生类的虚函数表。 - 程序运行时，通过
vptr找到虚函数表，再根据表中的地址调用对应的函数，从而实现动态多态。
6.2 核心特点
- 虚函数表属于类，所有对象共享同一个虚函数表，节省内存空间。
- 虚函数指针属于对象，每个对象都有自己的
vptr，指向对应类的虚函数表。 - 派生类的虚函数表会继承基类的虚函数表，并重写被覆盖的虚函数地址。
七、本章总结
多态分为静态多态和动态多态，静态多态编译时确定，动态多态运行时确定。 动态多态的实现条件是：继承关系 + 虚函数重写 + 基类指针/引用指向派生类对象。 虚析构函数可以解决基类指针释放派生类对象时的资源泄漏问题。 抽象类包含纯虚函数，无法实例化，用于定义接口规范，强制派生类实现具体功能。 多态的核心优势是代码复用、功能扩展、符合开闭原则，是大型项目设计的核心机制。
