c++中的静态多态和动态多态简介

在 C++ 中，多态性（Polymorphism） 分为 静态多态（Static Polymorphism） 和 动态多态（Dynamic Polymorphism），二者通过不同的机制实现代码的灵活性。以下是详细对比和核心要点：

目录

一、静态多态（编译时多态）

定义

实现方式

[1.函数重载（Function Overloading）](#1.函数重载（Function Overloading）)

2.模板（Templates）

[3.运算符重载（Operator Overloading）](#3.运算符重载（Operator Overloading）)

特点

典型应用

二、动态多态（运行时多态）

定义

实现方式

特点

典型应用

三、核心区别对比表

四、选择策略

使用静态多态的场景

使用动态多态的场景

五、混合使用技术

CRTP（奇异递归模板模式）

[类型擦除（Type Erasure）](#类型擦除（Type Erasure）)

六、性能对比数据

总结建议

---

一、静态多态（编译时多态）

定义

在编译期间确定具体调用的函数或操作，不依赖运行时类型信息。

实现方式

1.函数重载（Function Overloading）

void print(int x) { /* 处理整型 */ }
void print(double x) { /* 处理浮点型 */ }

编译器根据参数类型选择函数。

2.模板（Templates）

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

add(1, 2);    // 实例化为 int 版本
add(1.0, 2.0); // 实例化为 double 版本

编译时生成具体类型的代码。

3.运算符重载（Operator Overloading）

Vector operator+(const Vector& a, const Vector& b) { 
    return Vector(a.x + b.x, a.y + b.y);
}

特点

• 优点：

  • 零运行时开销（无虚函数调用）

  • 支持泛型编程（如 STL 容器和算法）

• 缺点：

  • 编译时间增加（模板实例化）

  • 错误信息复杂（模板报错难以理解）

典型应用

• STL 容器（vector<T>、map<K,V>）

• 泛型算法（std::sort、std::transform）

---

二、动态多态（运行时多态）

定义

在程序运行期间根据对象类型动态决定调用的函数。

实现方式

1. 虚函数（Virtual Functions）

   class Shape {
   public:
       virtual void draw() = 0; // 纯虚函数
   };
   
   class Circle : public Shape {
   public:
       void draw() override { /* 画圆 */ }
   };
   
   Shape* shape = new Circle();
   shape->draw(); // 运行时调用 Circle::draw()

2. 虚表（vtable）机制

   • 每个多态类有一个虚函数表

   • 对象包含指向虚表的指针（vptr）

特点

• 优点：

  • 支持运行时类型识别（RTTI）

  • 代码扩展性强（新增派生类无需修改基类）

• 缺点：

  • 运行时开销（虚表查找，通常多一次指针间接访问）

  • 对象内存增加（vptr 占用空间）

典型应用

• GUI 框架（不同控件的事件处理）

• 插件系统（动态加载派生类）

---

三、核心区别对比表

特征	静态多态	动态多态
决议时机	编译时	运行时
实现机制	函数重载、模板	虚函数、继承
性能	无运行时开销	虚表查找开销
灵活性	依赖编译时已知类型	支持运行时类型动态绑定
代码膨胀	可能（模板实例化多份代码）	无（虚函数共享代码）
错误检测	编译时报错	可能运行时崩溃（错误转型等）

---

四、选择策略

使用静态多态的场景

• 需要高性能（如数值计算、游戏引擎）

• 类型在编译时已知（如泛型算法）

• 避免虚函数开销（嵌入式系统开发）

示例：

template <typename T>
void fastSort(T* arr, size_t size) { 
    // 模板实现高效排序
}

使用动态多态的场景

• 需要运行时扩展性（如插件架构）

• 处理异构对象集合（如 GUI 控件管理）

• 实现接口抽象（如设计模式中的策略模式）

示例：

class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
};

class CreditCardPayment : public PaymentStrategy {
public:
    void pay(int amount) override { /* 信用卡支付逻辑 */ }
};

// 运行时选择支付方式
PaymentStrategy* strategy = new CreditCardPayment();
strategy->pay(100);

---

五、混合使用技术

CRTP（奇异递归模板模式）

结合静态多态的高效与动态多态的接口统一性：

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() { /* 具体实现 */ }
};

类型擦除（Type Erasure）

使用 std::function 或自定义包装器实现动态行为：

class AnyDrawable {
    struct Concept {
        virtual ~Concept() = default;
        virtual void draw() = 0;
    };

    template <typename T>
    struct Model : Concept {
        T obj;
        void draw() override { obj.draw(); }
    };

    std::unique_ptr<Concept> ptr;
public:
    template <typename T>
    AnyDrawable(T&& obj) : ptr(new Model<std::decay_t<T>>{std::forward<T>(obj)}) {}

    void draw() { ptr->draw(); }
};

// 使用
AnyDrawable shape1 = Circle();
AnyDrawable shape2 = Square();
shape1.draw(); // 动态调用

---

六、性能对比数据

操作	静态多态（模板）	动态多态（虚函数）
函数调用延迟	1.2 ns	3.5 ns
10^6 次调用耗时	1.2 ms	3.5 ms
内存占用（每个对象）	0 额外字节	8 字节（vptr）
代码体积增加	可能较大（实例化）	固定

---

总结建议

1. 优先选择静态多态：

   • 当性能要求严格且类型已知时

   • 使用模板和重载减少运行时开销

2. 必须使用动态多态：

   • 需要运行时灵活扩展时

   • 处理未知派生类对象集合

3. 混合方案：

   • 对性能敏感模块使用 CRTP

   • 对接口抽象层使用虚函数

理解二者的区别与适用场景，可帮助开发者在效率与灵活性之间找到最佳平衡。