C++中的多态：动态多态与静态多态详解

多态是面向对象编程的三大特性之一，C++提供了两种主要的多态形式：动态多态和静态多态。本文将详细解释它们的区别，并通过代码示例进行说明。

什么是多态？

多态（Polymorphism）指同一个接口可以表现出不同的行为。在C++中，这允许我们使用统一的接口来处理不同类型的对象。

动态多态（运行时多态）

动态多态在程序运行时确定调用哪个函数，主要通过虚函数和继承机制实现。

实现机制

使用虚函数（virtual function）
通过继承关系
运行时通过虚函数表（vtable）决定调用哪个函数

代码示例

1#include <iostream>
2using namespace std;
3
4// 基类
5class Animal {
6public:
7    // 虚函数
8    virtual void makeSound() {
9        cout << "Animal makes a sound" << endl;
10    }
11    
12    virtual ~Animal() = default; // 虚析构函数
13};
14
15// 派生类
16class Dog : public Animal {
17public:
18    void makeSound() override {
19        cout << "Dog barks: Woof! Woof!" << endl;
20    }
21};
22
23class Cat : public Animal {
24public:
25    void makeSound() override {
26        cout << "Cat meows: Meow! Meow!" << endl;
27    }
28};
29
30// 使用动态多态
31void animalSound(Animal* animal) {
32    animal->makeSound(); // 运行时决定调用哪个makeSound
33}
34
35int main() {
36    Dog dog;
37    Cat cat;
38    Animal animal;
39    
40    // 通过基类指针调用，表现出多态行为
41    Animal* animals[] = {&animal, &dog, &cat};
42    
43    for (auto* animal : animals) {
44        animalSound(animal);
45    }
46    
47    return 0;
48}
49

输出：

1Animal makes a sound
2Dog barks: Woof! Woof!
3Cat meows: Meow! Meow!
4

动态多态特点

运行时绑定：函数调用在运行时决定
灵活性高：可以在运行时改变行为
性能开销：有虚函数表查找的开销
必须使用指针或引用：通过基类指针或引用调用

静态多态（编译时多态）

静态多态在编译时确定调用哪个函数，主要通过函数重载和模板实现。

1. 函数重载

1#include <iostream>
2using namespace std;
3
4class Calculator {
5public:
6    // 函数重载 - 静态多态
7    int add(int a, int b) {
8        return a + b;
9    }
10    
11    double add(double a, double b) {
12        return a + b;
13    }
14    
15    string add(const string& a, const string& b) {
16        return a + b;
17    }
18};
19
20int main() {
21    Calculator calc;
22    
23    cout << "Int addition: " << calc.add(5, 3) << endl;
24    cout << "Double addition: " << calc.add(5.5, 3.3) << endl;
25    cout << "String addition: " << calc.add("Hello, ", "World!") << endl;
26    
27    return 0;
28}
29

输出：

1Int addition: 8
2Double addition: 8.8
3String addition: Hello, World!
4

2. 模板（泛型编程）

1#include <iostream>
2#include <vector>
3#include <list>
4using namespace std;
5
6// 函数模板 - 静态多态
7template<typename T>
8T multiply(T a, T b) {
9    return a * b;
10}
11
12// 类模板
13template<typename Container>
14void printContainer(const Container& container) {
15    for (const auto& item : container) {
16        cout << item << " ";
17    }
18    cout << endl;
19}
20
21// 特化示例
22template<>
23string multiply<string>(string a, string b) {
24    return "String multiplication not supported";
25}
26
27int main() {
28    // 模板函数使用
29    cout << "Int multiplication: " << multiply(5, 3) << endl;
30    cout << "Double multiplication: " << multiply(5.5, 2.0) << endl;
31    cout << "String multiplication: " << multiply<string>("hello", "world") << endl;
32    
33    // 模板类使用
34    vector<int> vec = {1, 2, 3, 4, 5};
35    list<string> lst = {"apple", "banana", "cherry"};
36    
37    cout << "Vector: ";
38    printContainer(vec);
39    
40    cout << "List: ";
41    printContainer(lst);
42    
43    return 0;
44}
45

输出：

1Int multiplication: 15
2Double multiplication: 11
3String multiplication: String multiplication not supported
4Vector: 1 2 3 4 5 
5List: apple banana cherry 
6

3. CRTP（奇异递归模板模式）

1#include <iostream>
2using namespace std;
3
4// CRTP基类
5template<typename Derived>
6class AnimalBase {
7public:
8    void makeSound() {
9        static_cast<Derived*>(this)->makeSoundImpl();
10    }
11};
12
13// 派生类
14class Dog : public AnimalBase<Dog> {
15public:
16    void makeSoundImpl() {
17        cout << "Dog barks: Woof! Woof!" << endl;
18    }
19};
20
21class Cat : public AnimalBase<Cat> {
22public:
23    void makeSoundImpl() {
24        cout << "Cat meows: Meow! Meow!" << endl;
25    }
26};
27
28// 使用静态多态
29template<typename T>
30void animalSound(AnimalBase<T>& animal) {
31    animal.makeSound(); // 编译时决定调用哪个函数
32}
33
34int main() {
35    Dog dog;
36    Cat cat;
37    
38    animalSound(dog);
39    animalSound(cat);
40    
41    return 0;
42}
43

输出：

1Dog barks: Woof! Woof!
2Cat meows: Meow! Meow!
3

动态多态 vs 静态多态

特性	动态多态	静态多态
绑定时间	运行时	编译时
实现机制	虚函数、继承	模板、函数重载
性能	有运行时开销（虚表查找）	无运行时开销
灵活性	运行时决定行为	编译时决定行为
二进制大小	较小	可能较大（模板实例化）
调试难度	相对容易	相对困难
使用场景	需要运行时动态行为	性能要求高，类型已知

实际应用建议

使用动态多态的场景：

需要在运行时决定对象类型
有复杂的继承层次结构
需要插件架构或动态加载
代码可读性和维护性更重要

使用静态多态的场景：

性能是关键因素
类型在编译时已知
需要避免虚函数开销
使用模板元编程

总结

C++中的多态提供了强大的代码复用和灵活性：

动态多态通过虚函数提供运行时灵活性，适合需要动态行为变化的场景
静态多态通过模板和重载提供零开销的抽象，适合性能敏感的场景

在实际开发中，应根据具体需求选择合适的多态方式，有时甚至可以结合使用两者以获得最佳效果。理解这两种多态的区别和适用场景，有助于编写更高效、更灵活的C++代码。

《C++中的多态：动态多态与静态多态详解》是转载文章，点击查看原文。