【C++】一文看懂 C++ 多态：动态与静态多态的全面剖析

---

探索 C++ 中的多态：实现动态行为的关键

在 C++ 中，多态性（Polymorphism）是面向对象编程的核心概念之一。它允许同一个函数或操作在不同的上下文中表现出不同的行为，从而增强代码的灵活性和可扩展性。本文将深入探讨 C++ 中的多态性，解释它的类型，并通过示例演示如何在实际编程中运用这一强大的特性。

1. 什么是多态？

多态来源于希腊语，意为“多种形态”。在编程中，多态性指的是在相同的接口下，不同的数据类型可以表现出不同的行为。C++ 中的多态性主要分为两种：编译时多态 和 运行时多态。

1.1 编译时多态

编译时多态也称为静态多态，主要通过函数重载和运算符重载来实现。编译器在编译期间决定调用哪个函数或运算符。

1.2 运行时多态

运行时多态也称为动态多态，通过继承和虚函数实现。程序在运行时根据对象的实际类型来决定调用哪个函数。

2. 编译时多态的实现

2.1 函数重载

函数重载允许在同一个作用域内定义多个函数，这些函数具有相同的名字，但参数列表不同。

#include <iostream>
using namespace std;

class Printer {
public:
    void print(int i) {
        cout << "Printing int: " << i << endl;
    }

    void print(double f) {
        cout << "Printing float: " << f << endl;
    }

    void print(const string& s) {
        cout << "Printing string: " << s << endl;
    }
};

int main() {
    Printer p;
    p.print(5);
    p.print(5.5);
    p.print("Hello World");
    return 0;
}

输出:

Printing int: 5
Printing float: 5.5
Printing string: Hello World

2.2 运算符重载

运算符重载允许用户定义自定义类型的运算符行为。

#include <iostream>
using namespace std;

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

    Complex operator + (const Complex& other) {
        return Complex(real + other.real, imag + other.imag);
    }

    void display() const {
        cout << "Complex number: " << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    c3.display();
    return 0;
}

输出:

Complex number: 4 + 6i

3. 运行时多态的实现

运行时多态通过虚函数（virtual function）和指针或引用来实现。基类中的虚函数可以在派生类中被重写，实际调用的函数根据对象的实际类型在运行时确定。

3.1 虚函数

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() const {
        cout << "Animal speaks" << endl;
    }
};

class Dog : public Animal {
public:
    void speak() const override {
        cout << "Dog barks" << endl;
    }
};

class Cat : public Animal {
public:
    void speak() const override {
        cout << "Cat meows" << endl;
    }
};

void makeAnimalSpeak(const Animal& a) {
    a.speak();
}

int main() {
    Dog d;
    Cat c;
    makeAnimalSpeak(d);
    makeAnimalSpeak(c);
    return 0;
}

输出:

Dog barks
Cat meows

3.2 纯虚函数与抽象类

纯虚函数是一种没有实现的虚函数，必须在派生类中实现。包含纯虚函数的类称为抽象类，不能实例化，只能作为基类。

#include <iostream>
using namespace std;

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

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

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

int main() {
    Circle c;
    Square s;
    Shape* shapes[] = { &c, &s };
    
    for (Shape* shape : shapes) {
        shape->draw();
    }
    
    return 0;
}

输出:

Drawing Circle
Drawing Square

4. 多态的实际应用

多态性在软件设计中具有广泛应用，特别是在实现设计模式（如工厂模式、策略模式）时。它允许开发者编写更通用、更灵活的代码，能够处理未来可能出现的新需求。

例如，在游戏开发中，可以有一个基类 Character，然后不同的角色（如 Warrior、Mage）继承自 Character。通过多态性，可以用基类指针或引用来处理不同类型的角色，而不需要在代码中写死具体的类型。

5. 总结

• 编译时多态 通过函数重载和运算符重载实现，允许在编译阶段确定具体的函数调用。
• 运行时多态 通过虚函数和继承实现，允许在运行时根据对象的实际类型确定具体的函数调用。
• 多态性极大地提高了代码的灵活性和可维护性，是面向对象编程中不可或缺的组成部分。