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

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

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

3.1 动态多态的实现条件

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

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

3.2 虚函数的定义与使用

虚函数的定义是在基类成员函数前加 virtual 关键字。派生类重写时可以省略 virtual，但为了代码可读性，建议保留。

基础案例：动物叫的多态实现

#include <iostream>
#include <string>
using namespace std;

// 基类：动物
class Animal {
public:
    // 虚函数：动物叫
    virtual void bark() {
        cout << "动物发出叫声" << endl;
    }
};

// 派生类：猫
class Cat : public Animal {
public:
    // 重写基类的虚函数
    void bark() 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;
}

运行结果：

猫：喵喵喵
狗：汪汪汪

需要注意的细节：

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

3.3 虚析构函数：解决资源泄漏问题

当基类指针指向派生类对象并通过 delete 释放时，如果基类析构函数不是虚函数，会导致派生类的析构函数无法被调用，从而引发内存泄漏。

解决方案：将基类的析构函数声明为虚析构函数。

非虚析构的问题演示

#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;
}

运行结果（存在问题）：

Base 构造函数
Derived 构造函数
Base 析构函数

修复后的代码（虚析构函数）

#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;
}

运行结果（正确释放）：

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;
}

运行结果：

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

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

在实际开发中，我们常需要设计支持多种运算的计算器，利用多态可以让系统符合开闭原则，即对扩展开放，对修改关闭。

需求分析

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

完整代码实现

#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;
}

运行结果：

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

六、核心原理：虚函数表

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

工作机制

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

核心特点

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

七、总结

• 多态分为静态多态（编译期）和动态多态（运行期）。
• 动态多态需满足继承、虚函数重写、基类指针/引用三个条件。
• 虚析构函数能有效防止基类指针释放派生类对象时的资源泄漏。
• 抽象类通过纯虚函数定义接口规范，强制派生类实现功能。
• 多态的核心优势在于代码复用、功能扩展及符合开闭原则，是大型项目设计的基石。