C++ 多态：面向对象的动态行为核心机制

三、动态多态：运行时确定的多态性

动态多态是面向对象编程的核心，其关键是虚函数和基类指针/引用指向派生类对象，调用关系在程序运行时才确定。

3.1 动态多态的实现条件

实现动态多态必须同时满足三个条件：

1. 存在继承关系，且通常是公有继承。
2. 基类中定义虚函数，派生类重写该虚函数。
3. 使用基类的指针或引用指向派生类对象。

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->bark(); // 输出狗的叫声
    // 释放内存
    delete animal1;
    delete animal2;
    return 0;
}

3.2.2 运行结果

猫：喵喵喵 狗：汪汪汪

注意事项

1. override 关键字用于显式标记派生类对基类虚函数的重写，编译器会检查重写的合法性，建议添加。
2. 如果基类指针指向基类对象，则调用基类的虚函数；指向派生类对象，则调用派生类重写的函数。
3. 虚函数的重写要求函数名、参数列表、返回值类型完全一致，否则会被视为派生类的新函数，而非重写。

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 抽象类的特性

1. 抽象类不能创建对象，只能定义指针或引用。
2. 派生类必须重写抽象类的所有纯虚函数，否则派生类也会成为抽象类。
3. 抽象类的核心作用是定义接口规范，强制派生类实现具体功能。

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 = 3.1415926;
public:
    Circle(double r) : radius(r) {}
    double getArea() override { return PI * radius * radius; }
    double getPerimeter() override { return 2 * PI * radius; }
};

// 通用函数：打印图形信息
void printShapeInfo(Shape *shape) {
    cout << "面积：" << shape->getArea() << endl;
    cout << "周长：" << shape->getPerimeter() << endl;
}

int main() {
    // 抽象类不能实例化对象
    // Shape s; // 编译错误
    Shape *rect = new Rectangle(5, 3);
    Shape *circle = new Circle(4);
    cout << "矩形信息：" << endl;
    printShapeInfo(rect);
    cout << "----------------" << endl;
    cout << "圆形信息：" << endl;
    printShapeInfo(circle);
    delete rect;
    delete circle;
    return 0;
}

4.4 运行结果

矩形信息： 面积：15 周长：16 ---------------- 圆形信息： 面积：50.2655 周长：25.1327

五、多态的实战案例：计算器的动态扩展

需求：设计一个支持多种运算的计算器，利用多态特性，让计算器可以动态扩展新的运算类型，无需修改原有代码（符合开闭原则）。

5.1 需求分析

1. 定义抽象基类 Operation，包含纯虚函数 calculate，用于计算结果。
2. 派生类分别实现加法 Add、减法 Sub、乘法 Mul、除法 Div。
3. 设计计算器类 Calculator，接收 Operation 指针，调用计算方法。
4. 新增运算类型时，只需新增派生类，无需修改计算器核心代码。

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 { return num1 * num2; }
};

// 除法运算
class Div : public Operation {
public:
    double calculate() override {
        if (num2 == 0) throw invalid_argument("除数不能为 0");
        return num1 / num2;
    }
};

// 计算器类
class Calculator {
private:
    Operation *op;
public:
    Calculator(Operation *operation) : op(operation) {}
    double compute(double n1, double n2) {
        op->setNum(n1, n2);
        return op->calculate();
    }
    ~Calculator() { delete op; }
};

int main() {
    try {
        // 加法计算
        Calculator addCalc(new Add());
        cout << "10 + 5 = " << addCalc.compute(10, 5) << endl;
        // 减法计算
        Calculator subCalc(new Sub());
        cout << "10 - 5 = " << subCalc.compute(10, 5) << endl;
        // 乘法计算
        Calculator mulCalc(new Mul());
        cout << "10 * 5 = " << mulCalc.compute(10, 5) << endl;
        // 除法计算
        Calculator divCalc(new Div());
        cout << "10 / 5 = " << divCalc.compute(10, 5) << endl;
        // 测试除数为 0
        cout << "10 / 0 = " << divCalc.compute(10, 0) << endl;
    } catch (const exception& e) {
        cout << "错误：" << e.what() << endl;
    }
    return 0;
}

5.3 运行结果

10 + 5 = 15 10 - 5 = 5 10 * 5 = 50 10 / 5 = 2 错误：除数不能为 0

六、多态的核心原理：虚函数表

C++ 动态多态的底层实现依赖虚函数表（vtable）和虚函数指针（vptr），理解其原理能帮助我们更好地使用多态。

6.1 虚函数表的工作机制

1. 当类中包含虚函数时，编译器会为该类生成一个虚函数表，表中存储的是虚函数的地址。
2. 每个对象的内存布局中，会有一个隐藏的虚函数指针 vptr，指向所属类的虚函数表。
3. 当基类指针指向派生类对象时，vptr 会指向派生类的虚函数表。
4. 程序运行时，通过 vptr 找到虚函数表，再根据表中的地址调用对应的函数，从而实现动态多态。

6.2 核心特点

• 虚函数表属于类，所有对象共享同一个虚函数表，节省内存空间。
• 虚函数指针属于对象，每个对象都有自己的 vptr，指向对应类的虚函数表。
• 派生类的虚函数表会继承基类的虚函数表，并重写被覆盖的虚函数地址。

七、本章总结

多态分为静态多态和动态多态，静态多态编译时确定，动态多态运行时确定。 动态多态的实现条件是：继承关系 + 虚函数重写 + 基类指针/引用指向派生类对象。 虚析构函数可以解决基类指针释放派生类对象时的资源泄漏问题。 抽象类包含纯虚函数，无法实例化，用于定义接口规范，强制派生类实现具体功能。 多态的核心优势是代码复用、功能扩展、符合开闭原则，是大型项目设计的核心机制。