C++ 入门六：多态 —— 同一接口的多种实现之道

在面向对象编程中，多态是最具魅力的特性之一。它允许我们通过统一的接口处理不同类型的对象，实现 “一个接口，多种实现”。本章将从基础概念到实战案例，逐步解析多态的核心原理与应用场景，帮助新手掌握这一关键技术。

一、多态概述：代码的 “七十二变”

1. 什么是多态？

多态是面向对象编程的核心特性，指同一接口在不同对象上表现出不同行为。例如：

一个绘图函数 draw()，作用于 “圆形” 时绘制圆形，作用于 “矩形” 时绘制矩形。
动物类的 speak() 方法，狗调用时 “汪汪叫”，猫调用时 “喵喵叫”。

核心价值：通过基类指针或引用统一管理派生类对象，大幅减少重复代码，提升系统扩展性。例如，用 “动物” 指针数组存储 “狗” 和 “猫”，调用 speak() 时自动匹配具体行为。

2. 生活中的多态映射

想象你有一个万能遥控器，能控制电视、空调、风扇。虽然设备不同，但遥控器的 “开 / 关” 按钮（统一接口）会根据设备类型执行不同操作 —— 这就是多态的现实类比。C++ 中，通过基类定义统一接口，派生类实现具体逻辑，最终通过基类指针调用，实现动态行为切换。

二、构成多态的三大条件：缺一不可

多态的实现需要满足三个严格条件，缺少任何一个都会导致失效。

条件 1：存在继承关系

必须存在基类（父类）和派生类（子类），形成 “is-a” 关系。

// 基类：动物
class Animal { /* ... */ };
// 派生类：狗是一种动物（公有继承）
class Dog : public Animal { /* ... */ };
class Cat : public Animal { /* ... */ };

条件 2：基类声明虚函数，派生类完全覆盖

虚函数：在基类中用 virtual 关键字声明的函数，派生类需以完全相同的函数原型（函数名、参数列表、返回值）重写。

错误示例（参数不同导致 “隐藏” 而非 “覆盖”）：

class Animal {
    virtual void speak() { /* ... */ } // 基类虚函数
};
class Dog : public Animal {
    void speak(int volume) { /* ... */ } // 参数不同，不构成多态，而是隐藏
};

条件 3：通过基类指针 / 引用调用虚函数

只有通过基类指针或引用调用虚函数时，才会在运行时根据对象实际类型选择派生类实现（动态绑定）。直接使用对象调用仍按对象类型静态绑定。

三、虚函数：多态的 “魔法开关”

1. 定义与使用步骤

步骤 1：基类声明虚函数

在基类中用 virtual 关键字声明接口，提供默认实现（可选）：

class Animal {
public:
    virtual void speak() { // 虚函数，基类默认行为
        cout << "Animal makes a sound." << endl;
    }
};

步骤 2：派生类重写虚函数

派生类中用相同原型重写，推荐使用 override 关键字（C++11 后可选，显式标识重写，帮助编译器检查）：

class Dog : public Animal {
public:
    void speak() override { // 正确重写
        cout << "Woof! Woof!" << endl;
    }
};

class Cat : public Animal {
public:
    void speak() override { // 正确重写
        cout << "Meow~" << endl;
    }
};

步骤 3：基类指针调用，实现动态绑定

int main() {
    Animal* pet1 = new Dog();  // 基类指针指向派生类对象
    Animal* pet2 = new Cat();

    pet1->speak();  // 输出：Woof! Woof!（调用Dog的实现）
    pet2->speak();  // 输出：Meow~（调用Cat的实现）

    delete pet1; // 释放内存（需虚析构函数，见注意事项）
    delete pet2;
    return 0;
}

2. 虚函数注意事项

构造函数不能是虚函数：
构造对象时，类的类型已经确定（基类或派生类），无需多态。若声明为虚函数，编译器会报错。

析构函数建议声明为虚函数：
确保释放派生类对象时调用正确的析构函数，避免内存泄漏。

class Animal {
public:
    virtual ~Animal() { // 虚析构函数
        cout << "Animal destroyed." << endl;
    }
};

动态绑定的限制：
只有通过指针或引用调用虚函数时才生效，直接用对象调用会按对象类型静态绑定：
```
Dog dog;
dog.speak(); // 直接调用Dog的speak（静态绑定，无需virtual也能正确调用）
```

四、纯虚函数与抽象类：强制派生类实现的 “契约”

1. 纯虚函数

定义：基类中声明但不实现的虚函数，语法为 virtual 返回值类型函数名(参数列表) = 0;。

作用：强制派生类必须重写该函数，否则派生类无法实例化（成为抽象类）。

class Shape { // 抽象基类
public:
    virtual float area() = 0; // 纯虚函数，无函数体
};

2. 抽象类

概念：包含至少一个纯虚函数的类，不能直接创建对象，只能作为基类被继承。

派生类要求：必须实现基类所有纯虚函数，否则仍是抽象类，无法实例化。

class Circle : public Shape {
public:
    float area(float r) { // 错误！参数不同，未正确覆盖纯虚函数
        return 3.14 * r * r;
    }
}; // 编译错误：Circle仍是抽象类，因为未正确重写area()

class Rectangle : public Shape {
public:
    float area() override { // 正确重写（参数列表与基类一致）
        return width * height;
    }
private:
    float width, height;
};

五、多态实现原理：虚函数表（VTable）

1. 底层机制

虚函数表：编译器为每个包含虚函数的类生成一张表，存储虚函数的地址。派生类的虚函数表会覆盖基类的对应函数地址。
动态绑定：当基类指针调用虚函数时，编译器通过虚函数表找到对象实际类型（派生类）的函数地址，实现运行时动态调用。

2. 为什么需要虚函数表？

确保程序在运行时能根据对象的实际类型（而非指针类型）选择函数实现，这是多态 “晚绑定” 的核心。例如，基类指针指向派生类对象时，通过虚函数表找到派生类的重写函数，而非基类版本。

六、常见易错点与解决方案

1. 忘记声明 `virtual` 关键字

错误现象：基类函数未声明为虚函数，派生类重写无效，调用时仍执行基类版本。
```
class Animal {
    void speak() { /* 非虚函数 */ } // 错误：无virtual，多态失效
};
```
解决方案：基类中所有希望支持多态的函数必须声明为 virtual。

2. 派生类函数原型不匹配

错误现象：参数列表或返回值不同，导致 “隐藏” 而非 “覆盖”，多态失效。

class Dog : public Animal {
    void speak(string voice) { /* 参数不同 */ } // 隐藏基类speak()
};

解决方案：确保函数名、参数、返回值完全一致，推荐使用 override 关键字强制编译器检查。

3. 抽象类未实现所有纯虚函数

错误现象：派生类未实现基类的纯虚函数，导致派生类仍是抽象类，无法创建对象。
```
class Circle : public Shape { /* 未实现area() */ }; // 编译错误：无法实例化抽象类
```
解决方案：必须为每个纯虚函数提供实现，或继续将派生类声明为抽象类（保留未实现的纯虚函数）。

七、综合案例：实现 “多态绘图系统”

1. 定义抽象基类 `Shape`

#include <iostream>
using namespace std;

// 抽象基类：所有图形的接口
class Shape {
public:
    virtual void draw() = 0; // 纯虚函数，强制派生类实现
    virtual ~Shape() { /* 虚析构函数，确保正确释放内存 */ }
};

2. 派生类实现具体绘图逻辑

圆形类

class Circle : public Shape {
public:
    Circle(float r) : radius(r) {}
    void draw() override { // 重写纯虚函数
        cout << "绘制圆形，半径：" << radius << endl;
    }
private:
    float radius;
};

矩形类

class Rectangle : public Shape {
public:
    Rectangle(float w, float h) : width(w), height(h) {}
    void draw() override { // 重写纯虚函数
        cout << "绘制矩形，宽：" << width << "，高：" << height << endl;
    }
private:
    float width, height;
};

3. 多态调用：统一接口处理不同图形

// 多态函数：通过基类指针调用draw()
void drawAnyShape(Shape* shape) {
    shape->draw(); // 动态绑定，根据实际对象类型调用
}

int main() {
    // 创建派生类对象，用基类指针管理
    Shape* shapes[] = {
        new Circle(5.0f),
        new Rectangle(3.0f, 4.0f)
    };

    // 统一调用接口
    for (auto shape : shapes) {
        drawAnyShape(shape);
    }

    // 释放内存（虚析构函数确保正确释放派生类资源）
    for (auto shape : shapes) {
        delete shape;
    }

    return 0;
}

4. 输出结果

绘制圆形，半径：5.0
绘制矩形，宽：3.0，高：4.0

八、总结：多态的核心价值与学习路径

1. 知识图谱

多态
├─ 核心概念：同一接口不同行为，动态绑定（运行时确定实现）
├─ 实现条件：
│  ├─ 继承关系（is-a）
│  ├─ 基类虚函数 + 派生类完全重写（override）
│  └─ 通过基类指针/引用调用
├─ 关键特性：
│  ├─ 虚函数：声明virtual，析构函数建议设为虚函数
│  ├─ 纯虚函数与抽象类：强制派生类实现接口（=0）
├─ 底层原理：虚函数表（VTable）实现动态绑定
└─ 常见错误：未声明virtual、原型不匹配、抽象类未实现