简述一下 C++ 中的多态

C++ 中的多态（Polymorphism）

多态（Polymorphism） 是面向对象编程（OOP）中的重要特性，它允许同一个接口（基类方法）在不同的对象上具有不同的行为。C++ 的多态可以分为 编译时多态（静态多态） 和 运行时多态（动态多态） 两种。

1. 编译时多态（静态多态）

编译时多态是指在编译阶段就确定了调用哪个函数，主要包括：

① 函数重载（Function Overloading）

同名函数，参数不同（参数类型或数量不同）

#include <iostream>
using namespace std;

class Example {
public:
    void show(int x) { cout << "Integer: " << x << endl; }
    void show(double x) { cout << "Double: " << x << endl; }
    void show(string x) { cout << "String: " << x << endl; }
};

int main() {
    Example ex;
    ex.show(10);        // 调用 int 版本
    ex.show(3.14);      // 调用 double 版本
    ex.show("Hello");   // 调用 string 版本
    return 0;
}

② 运算符重载（Operator Overloading）

重载运算符，使其支持自定义数据类型

#include <iostream>
using namespace std;

class Complex {
public:
    int real, imag;
    Complex(int r, int i) : real(r), imag(i) {}

    // 重载 + 运算符
    Complex operator+(const Complex &c) {
        return Complex(real + c.real, imag + c.imag);
    }

    void display() { cout << real << " + " << imag << "i" << endl; }
};

int main() {
    Complex c1(3, 4), c2(1, 2);
    Complex c3 = c1 + c2; // 使用重载的 + 运算符
    c3.display();  // 输出：4 + 6i
    return 0;
}

③ 模板（Templates）

泛型编程，编译时确定类型

#include <iostream>
using namespace std;

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    cout << add(3, 4) << endl;      // 7 (int)
    cout << add(3.5, 2.1) << endl;  // 5.6 (double)
    return 0;
}

2. 运行时多态（动态多态）

运行时多态是在程序运行阶段决定调用哪个函数，主要依赖于虚函数（virtual functions）和动态绑定（dynamic binding）。

① 继承与虚函数（Virtual Function）

基类指针/引用指向派生类对象，并调用重写的方法

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() { cout << "Base class" << endl; }  // 虚函数
};

class Derived : public Base {
public:
    void show() override { cout << "Derived class" << endl; }  // 重写基类方法
};

int main() {
    Base* ptr;
    Derived obj;
    ptr = &obj;

    ptr->show();  // 运行时确定，调用 Derived::show()
    return 0;
}

🔹 关键点

• virtual关键字：告诉编译器该函数支持动态绑定（即运行时确定）。

• 基类指针指向子类对象，调用的方法由子类重写版本决定。

② 纯虚函数（Pure Virtual Function）与抽象类

纯虚函数用于定义接口，强制子类必须实现该方法

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override { cout << "Drawing Circle" << endl; }
};

int main() {
    // Shape obj; // ❌ 抽象类不能实例化
    Shape* shape = new Circle();
    shape->draw();  // 调用 Circle 的 draw()
    delete shape;
    return 0;
}

🔹 关键点

• 含有纯虚函数的类称为抽象类，不能实例化。

• 派生类必须实现纯虚函数，否则仍然是抽象类。

总结

• 静态多态 提高程序效率（编译时决定调用），但灵活性较低。

• 动态多态 提高程序扩展性（运行时决定调用），但有轻微性能开销。

✅ 应用场景

• 静态多态：适用于编译时确定类型的情况，如重载操作、模板。

• 动态多态：适用于需要运行时多态行为的场景，如 UI 组件绘制、策略模式等。

🚀 多态是面向对象编程的重要特性，使代码更具扩展性和可维护性！