编辑“︁C++ 多态”︁

= C++多态 =

'''多态'''（Polymorphism）是面向对象编程（OOP）的三大核心特性之一（另外两个是封装和继承）。在C++中，多态允许我们使用相同的接口来处理不同的数据类型或对象，从而提高代码的灵活性和可扩展性。多态主要通过'''虚函数'''（virtual functions）和'''函数重写'''（function overriding）来实现。

== 多态的类型 ==
C++支持两种主要的多态形式：
# '''编译时多态'''（静态多态）：通过函数重载和模板实现。
# '''运行时多态'''（动态多态）：通过虚函数和继承实现。

本文将重点讨论'''运行时多态'''，因为它更直接体现了面向对象编程的核心思想。

== 虚函数与运行时多态 ==
运行时多态的关键在于'''虚函数'''。虚函数允许派生类重写基类的函数，使得在运行时可以根据对象的实际类型调用相应的函数。

=== 语法 ===
<syntaxhighlight lang="cpp">
class Base {
public:
    virtual void show() {  // 声明为虚函数
        std::cout << "Base class show()" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {  // 重写基类的虚函数
        std::cout << "Derived class show()" << std::endl;
    }
};
</syntaxhighlight>

=== 示例 ===
<syntaxhighlight lang="cpp">
#include <iostream>

int main() {
    Base* basePtr;
    Derived derivedObj;
    
    basePtr = &derivedObj;  // 基类指针指向派生类对象
    
    // 运行时多态：调用的是Derived类的show()
    basePtr->show();  
    
    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
Derived class show()
</pre>

'''解释：'''
* 虽然<code>basePtr</code>是<code>Base*</code>类型，但它指向的是<code>Derived</code>对象。
* 由于<code>show()</code>是虚函数，程序会在运行时确定调用哪个版本的<code>show()</code>（这个过程称为'''动态绑定'''或'''晚绑定'''）。

== 纯虚函数与抽象类 ==
当我们需要定义一个接口而不提供实现时，可以使用'''纯虚函数'''。包含纯虚函数的类称为'''抽象类'''，不能被实例化。

=== 语法 ===
<syntaxhighlight lang="cpp">
class AbstractClass {
public:
    virtual void pureVirtualFunction() = 0;  // 纯虚函数
};
</syntaxhighlight>

=== 示例 ===
<syntaxhighlight lang="cpp">
#include <iostream>

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

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    
    double area() override {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Shape* shape = new Circle(5.0);
    std::cout << "Area: " << shape->area() << std::endl;
    
    delete shape;
    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
Area: 78.5397
</pre>

== 多态的工作原理 ==
多态的实现依赖于'''虚函数表'''（vtable）和'''虚指针'''（vptr）机制：

<mermaid>
classDiagram
    class Base {
        +vptr
        +virtual function1()
        +virtual function2()
    }
    class Derived {
        +vptr
        +override function1()
        +override function2()
    }
    Base <|-- Derived
    note for Base "vtable for Base\n---\n&function1 (Base::function1)\n&function2 (Base::function2)"
    note for Derived "vtable for Derived\n---\n&function1 (Derived::function1)\n&function2 (Derived::function2)"
</mermaid>

* 每个包含虚函数的类都有一个'''虚函数表'''（vtable），其中存储了虚函数的地址。
* 每个对象包含一个'''虚指针'''（vptr），指向其类的vtable。
* 调用虚函数时，程序通过vptr找到正确的函数实现。

== 实际应用案例 ==
多态在现实编程中有广泛应用，例如：

=== GUI框架中的事件处理 ===
<syntaxhighlight lang="cpp">
class Widget {
public:
    virtual void onClick() = 0;
};

class Button : public Widget {
public:
    void onClick() override {
        std::cout << "Button clicked!" << std::endl;
    }
};

class Checkbox : public Widget {
public:
    void onClick() override {
        std::cout << "Checkbox toggled!" << std::endl;
    }
};

void handleEvent(Widget* widget) {
    widget->onClick();  // 多态调用
}
</syntaxhighlight>

=== 游戏开发中的实体系统 ===
<syntaxhighlight lang="cpp">
class GameObject {
public:
    virtual void update() = 0;
    virtual void render() = 0;
};

class Player : public GameObject {
    void update() override { /* 玩家更新逻辑 */ }
    void render() override { /* 玩家渲染逻辑 */ }
};

class Enemy : public GameObject {
    void update() override { /* 敌人更新逻辑 */ }
    void render() override { /* 敌人渲染逻辑 */ }
};
</syntaxhighlight>

== 多态的优点 ==
* '''代码复用'''：通过继承共享接口
* '''可扩展性'''：添加新类不影响现有代码
* '''接口一致性'''：统一的方式处理不同对象

== 注意事项 ==
1. 虚函数调用有轻微性能开销（通过vtable查找）
2. 构造函数和析构函数中不应调用虚函数
3. 基类析构函数应声明为virtual，确保正确释放资源

== 总结 ==
C++多态是面向对象编程的强大特性，通过虚函数和继承实现运行时动态绑定。它使代码更加灵活、可扩展，是设计复杂系统的重要工具。理解多态机制（特别是vtable和vptr）对于编写高效、可维护的C++代码至关重要。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 面向对象高级]]