MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++多态的概念与应用场景

2021-12-235.4k 阅读

C++多态的概念

多态的定义

在C++中，多态性（Polymorphism）是面向对象编程的重要特性之一。它允许我们以统一的方式处理不同类型的对象，通过基类的指针或引用调用不同派生类中的同名函数，从而实现行为的多样化。简单来说，多态就是“一种接口，多种实现”。

从更深入的层面理解，C++中的多态是基于继承体系的。当存在一个基类和多个派生类，且这些类中有同名函数时，通过基类指针或引用调用该函数，会根据实际指向或引用的对象类型来决定调用哪个类中的函数版本。这种机制使得程序在运行时能够根据对象的实际类型来选择合适的行为，而不是在编译时就确定，这就是所谓的动态绑定（Dynamic Binding），它是实现多态的关键。

多态的分类

C++中的多态主要分为两种类型：编译时多态（静态多态）和运行时多态（动态多态）。

编译时多态（静态多态）

编译时多态是通过函数重载（Function Overloading）和模板（Templates）来实现的。

  • 函数重载：在同一个作用域内，可以定义多个同名函数，但这些函数的参数列表（参数个数、参数类型或参数顺序）必须不同。编译器在编译阶段根据函数调用时传递的参数来决定调用哪个重载版本的函数。例如：
#include <iostream>

// 函数重载示例
void print(int num) {
    std::cout << "打印整数: " << num << std::endl;
}

void print(double num) {
    std::cout << "打印双精度浮点数: " << num << std::endl;
}

int main() {
    print(5);
    print(3.14);
    return 0;
}

在上述代码中，print函数被重载，根据传递参数的类型不同，编译器会在编译时确定调用合适的函数版本。

  • 模板：模板包括函数模板和类模板。函数模板允许我们编写一个通用的函数，它可以处理不同类型的数据，而不需要为每种数据类型都编写一个单独的函数。类模板则用于创建通用的类。编译器会根据模板参数的类型生成具体的函数或类实例。例如：
#include <iostream>

// 函数模板示例
template <typename T>
void display(T value) {
    std::cout << "值为: " << value << std::endl;
}

int main() {
    display(10);
    display(3.14);
    display('a');
    return 0;
}

在这个例子中，display函数模板可以处理不同类型的数据，编译器会根据实际传入的参数类型生成相应的函数实例。

运行时多态（动态多态）

运行时多态是通过虚函数（Virtual Functions）和指针或引用的动态绑定来实现的。

  • 虚函数：在基类中声明为virtual的成员函数，在派生类中可以被重写（Override）。虚函数的声明语法为在函数声明前加上virtual关键字。例如：
class Shape {
public:
    virtual void draw() {
        std::cout << "绘制形状" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "绘制矩形" << std::endl;
    }
};

在上述代码中，Shape类中的draw函数被声明为虚函数，Circle和Rectangle类重写了这个虚函数。这里override关键字是C++11引入的，用于显式表明派生类中的函数是对基类虚函数的重写，增加代码的可读性和可维护性，同时编译器也会进行相应的检查，防止错误重写。

  • 动态绑定：当通过基类的指针或引用调用虚函数时，程序会在运行时根据指针或引用实际指向的对象类型来决定调用哪个类中的虚函数版本，这就是动态绑定。例如：
int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Rectangle();

    shape1->draw();
    shape2->draw();

    delete shape1;
    delete shape2;
    return 0;
}

在这个例子中，shape1和shape2是Shape类型的指针，但分别指向Circle和Rectangle对象。当调用draw函数时，程序会根据指针实际指向的对象类型，分别调用Circle和Rectangle类中的draw函数，从而实现运行时多态。

多态的实现原理

运行时多态的实现依赖于虚函数表（Virtual Table，简称VTable）和虚函数表指针（Virtual Pointer，简称VPtr）。

  • 虚函数表：当一个类中声明了虚函数时，编译器会为这个类生成一个虚函数表。虚函数表是一个存储虚函数地址的数组，每个虚函数在表中都有一个对应的条目。如果派生类重写了基类的虚函数，那么虚函数表中对应条目的地址会被替换为派生类中重写函数的地址。
  • 虚函数表指针：每个包含虚函数的类的对象都有一个虚函数表指针，这个指针指向该类的虚函数表。当通过基类指针或引用调用虚函数时，程序首先通过虚函数表指针找到虚函数表，然后根据虚函数在表中的索引找到对应的函数地址，并调用该函数。

例如，对于前面的Shape、Circle和Rectangle类：

  • Shape类的对象包含一个虚函数表指针，指向Shape类的虚函数表，表中存储着Shape::draw函数的地址。
  • Circle类的对象也有一个虚函数表指针，指向Circle类的虚函数表。由于Circle重写了draw函数，其虚函数表中draw函数的条目存储的是Circle::draw函数的地址。
  • 同理，Rectangle类的对象的虚函数表指针指向Rectangle类的虚函数表，其中draw函数的条目存储的是Rectangle::draw函数的地址。

当通过Shape指针调用draw函数时，程序根据指针所指对象的虚函数表指针找到对应的虚函数表，进而调用正确的draw函数版本。

C++多态的应用场景

图形绘制系统

在图形绘制系统中，多态有着广泛的应用。假设有一个图形基类Shape，它有派生类Circle、Rectangle、Triangle等。每个图形都有一个draw函数用于绘制自身。通过多态，我们可以使用一个Shape指针数组来存储不同类型的图形对象，并统一调用draw函数进行绘制。例如：

#include <iostream>

class Shape {
public:
    virtual void draw() {
        std::cout << "绘制形状" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "绘制矩形" << std::endl;
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle();
    shapes[1] = new Rectangle();

    for (int i = 0; i < 2; ++i) {
        shapes[i]->draw();
    }

    for (int i = 0; i < 2; ++i) {
        delete shapes[i];
    }
    return 0;
}

在这个例子中，通过Shape指针数组，我们可以方便地管理和绘制不同类型的图形，而不需要为每种图形单独编写绘制逻辑，代码更加简洁和易于扩展。如果需要添加新的图形类型，只需要从Shape类派生并实现draw函数即可，而不需要修改现有的绘制逻辑。

游戏开发中的角色行为

在游戏开发中，不同类型的角色可能有不同的行为，如玩家角色、敌人角色等。可以定义一个基类Character，包含一些通用的属性和虚函数，如move、attack等。然后从Character类派生出具体的角色类，如Player和Enemy，并在派生类中重写虚函数以实现不同的行为。例如：

#include <iostream>

class Character {
public:
    virtual void move() {
        std::cout << "角色移动" << std::endl;
    }

    virtual void attack() {
        std::cout << "角色攻击" << std::endl;
    }
};

class Player : public Character {
public:
    void move() override {
        std::cout << "玩家移动" << std::endl;
    }

    void attack() override {
        std::cout << "玩家攻击" << std::endl;
    }
};

class Enemy : public Character {
public:
    void move() override {
        std::cout << "敌人移动" << std::endl;
    }

    void attack() override {
        std::cout << "敌人攻击" << std::endl;
    }
};

int main() {
    Character* player = new Player();
    Character* enemy = new Enemy();

    player->move();
    player->attack();

    enemy->move();
    enemy->attack();

    delete player;
    delete enemy;
    return 0;
}

这样，通过多态，游戏可以统一管理不同角色的行为，使得代码结构更加清晰，易于维护和扩展。例如，如果要为玩家角色添加新的技能，只需要在Player类中添加相应的函数并在合适的地方调用即可，不会影响到其他角色的代码。

插件系统

在开发插件系统时，多态是非常有用的。假设我们有一个主程序，需要加载不同的插件来实现不同的功能。可以定义一个插件基类Plugin，其中包含一些虚函数，如init用于初始化插件，execute用于执行插件的主要功能。然后每个具体的插件从Plugin类派生，并实现这些虚函数。例如：

#include <iostream>
#include <vector>

class Plugin {
public:
    virtual void init() {
        std::cout << "插件初始化" << std::endl;
    }

    virtual void execute() {
        std::cout << "插件执行" << std::endl;
    }
};

class MathPlugin : public Plugin {
public:
    void init() override {
        std::cout << "数学插件初始化" << std::endl;
    }

    void execute() override {
        std::cout << "执行数学计算" << std::endl;
    }
};

class GraphicsPlugin : public Plugin {
public:
    void init() override {
        std::cout << "图形插件初始化" << std::endl;
    }

    void execute() override {
        std::cout << "绘制图形" << std::endl;
    }
};

int main() {
    std::vector<Plugin*> plugins;
    plugins.push_back(new MathPlugin());
    plugins.push_back(new GraphicsPlugin());

    for (Plugin* plugin : plugins) {
        plugin->init();
        plugin->execute();
    }

    for (Plugin* plugin : plugins) {
        delete plugin;
    }
    return 0;
}

在这个例子中，主程序通过Plugin指针的向量来管理不同的插件。在加载和执行插件时，通过调用虚函数init和execute，程序会根据实际的插件类型调用相应的初始化和执行函数，实现了插件系统的灵活性和扩展性。如果需要添加新的插件，只需要从Plugin类派生并实现虚函数，而主程序的代码几乎不需要修改。

数据库访问层

在开发数据库访问层时，不同的数据库可能有不同的访问方式和操作语法，但我们希望提供一个统一的接口来操作数据库。可以定义一个数据库访问基类Database，包含虚函数如connect用于连接数据库，query用于执行查询语句等。然后针对不同的数据库（如MySQL、Oracle等）从Database类派生具体的数据库访问类，并在派生类中重写虚函数以实现具体的数据库操作。例如：

#include <iostream>

class Database {
public:
    virtual void connect() {
        std::cout << "连接数据库" << std::endl;
    }

    virtual void query(const std::string& sql) {
        std::cout << "执行查询: " << sql << std::endl;
    }
};

class MySQLDatabase : public Database {
public:
    void connect() override {
        std::cout << "连接MySQL数据库" << std::endl;
    }

    void query(const std::string& sql) override {
        std::cout << "在MySQL中执行查询: " << sql << std::endl;
    }
};

class OracleDatabase : public Database {
public:
    void connect() override {
        std::cout << "连接Oracle数据库" << std::endl;
    }

    void query(const std::string& sql) override {
        std::cout << "在Oracle中执行查询: " << sql << std::endl;
    }
};

int main() {
    Database* mysqlDB = new MySQLDatabase();
    Database* oracleDB = new OracleDatabase();

    mysqlDB->connect();
    mysqlDB->query("SELECT * FROM users");

    oracleDB->connect();
    oracleDB->query("SELECT * FROM employees");

    delete mysqlDB;
    delete oracleDB;
    return 0;
}

通过这种方式，应用程序可以通过Database指针来操作不同类型的数据库，而不需要了解具体数据库的细节，提高了代码的可移植性和可维护性。如果需要切换数据库类型，只需要在创建数据库对象时选择不同的派生类即可，应用程序的其他部分代码不需要大量修改。

事件处理机制

在图形用户界面（GUI）开发或其他事件驱动的系统中，多态常用于事件处理。可以定义一个事件基类Event，包含虚函数handle用于处理事件。然后从Event类派生出各种具体的事件类，如MouseEvent、KeyEvent等，并在派生类中重写handle函数以实现特定的事件处理逻辑。例如：

#include <iostream>

class Event {
public:
    virtual void handle() {
        std::cout << "处理事件" << std::endl;
    }
};

class MouseEvent : public Event {
public:
    void handle() override {
        std::cout << "处理鼠标事件" << std::endl;
    }
};

class KeyEvent : public Event {
public:
    void handle() override {
        std::cout << "处理键盘事件" << std::endl;
    }
};

void processEvent(Event* event) {
    event->handle();
}

int main() {
    MouseEvent mouseEvent;
    KeyEvent keyEvent;

    processEvent(&mouseEvent);
    processEvent(&keyEvent);
    return 0;
}

在这个例子中，processEvent函数接受一个Event指针，通过调用handle虚函数，程序可以根据实际的事件类型来调用相应的处理函数。这样，事件处理系统可以灵活地处理不同类型的事件，并且易于扩展新的事件类型。例如，如果需要添加新的事件类型如TouchEvent，只需要从Event类派生并实现handle函数，而事件处理的核心逻辑processEvent函数不需要修改。

容器与算法的结合

在C++标准库中，多态与容器和算法的结合也非常常见。例如，std::vector等容器可以存储基类指针，而算法可以通过这些指针操作不同派生类的对象，实现多态行为。假设我们有一个基类Animal及其派生类Dog和Cat，每个类都有一个speak虚函数。我们可以将Animal指针存储在std::vector中，并使用算法对这些对象进行操作。例如：

#include <iostream>
#include <vector>

class Animal {
public:
    virtual void speak() {
        std::cout << "动物发出声音" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "狗叫: 汪汪汪" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "猫叫: 喵喵喵" << std::endl;
    }
};

int main() {
    std::vector<Animal*> animals;
    animals.push_back(new Dog());
    animals.push_back(new Cat());

    for (Animal* animal : animals) {
        animal->speak();
    }

    for (Animal* animal : animals) {
        delete animal;
    }
    return 0;
}

通过这种方式，容器和算法可以统一处理不同类型的对象，充分发挥多态的优势，使得代码更加通用和灵活。同时，这也符合C++标准库中容器和算法分离的设计理念，提高了代码的复用性。

状态模式

状态模式是一种设计模式，多态在其中起着关键作用。在状态模式中，一个对象的行为取决于它的状态，并且当状态改变时，对象的行为也会改变。可以定义一个状态基类State，包含一些虚函数表示对象在该状态下的行为。然后从State类派生出具体的状态类，如OnState、OffState等，并在派生类中重写虚函数以实现特定状态下的行为。例如：

#include <iostream>

class Context;

class State {
public:
    virtual void handle(Context* context) = 0;
};

class OnState : public State {
public:
    void handle(Context* context) override {
        std::cout << "设备处于开启状态" << std::endl;
        // 可以在这里实现开启状态下的具体操作
    }
};

class OffState : public State {
public:
    void handle(Context* context) override {
        std::cout << "设备处于关闭状态" << std::endl;
        // 可以在这里实现关闭状态下的具体操作
    }
};

class Context {
private:
    State* state;
public:
    Context() : state(new OffState()) {}

    void setState(State* newState) {
        delete state;
        state = newState;
    }

    void request() {
        state->handle(this);
    }
};

int main() {
    Context context;
    context.request();

    context.setState(new OnState());
    context.request();

    return 0;
}

在这个例子中，Context类包含一个State指针，通过改变这个指针所指向的状态对象（从OffState切换到OnState等），Context对象的行为会发生改变。这里通过虚函数handle实现了状态相关的多态行为，使得代码更加清晰和易于维护。如果需要添加新的状态，只需要从State类派生并实现handle函数，而Context类的代码几乎不需要修改。

策略模式

策略模式也是一种利用多态的设计模式。策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。可以定义一个策略基类Strategy，包含一个虚函数表示执行算法的操作。然后从Strategy类派生出具体的策略类，如AddStrategy、MultiplyStrategy等，并在派生类中重写虚函数以实现具体的算法。例如：

#include <iostream>

class Strategy {
public:
    virtual int execute(int a, int b) = 0;
};

class AddStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a + b;
    }
};

class MultiplyStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a * b;
    }
};

class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* s) : strategy(s) {}

    int executeStrategy(int a, int b) {
        return strategy->execute(a, b);
    }
};

int main() {
    Strategy* addStrategy = new AddStrategy();
    Strategy* multiplyStrategy = new MultiplyStrategy();

    Context context1(addStrategy);
    Context context2(multiplyStrategy);

    std::cout << "加法结果: " << context1.executeStrategy(3, 5) << std::endl;
    std::cout << "乘法结果: " << context2.executeStrategy(3, 5) << std::endl;

    delete addStrategy;
    delete multiplyStrategy;
    return 0;
}

在这个例子中，Context类通过Strategy指针来选择不同的算法。通过多态，Context类可以在运行时动态切换使用不同的策略，使得代码更加灵活和可维护。如果需要添加新的算法，只需要从Strategy类派生并实现execute函数，而Context类的代码不需要大量修改。

总结多态应用场景的共性

从以上各种应用场景可以看出，多态的主要优势在于它提供了一种统一的方式来处理不同类型的对象，使得代码具有更好的扩展性、可维护性和灵活性。无论是图形绘制、游戏开发、插件系统，还是数据库访问、事件处理等领域，多态都能够帮助我们将不同的实现细节封装在派生类中，通过基类的统一接口进行调用，从而减少代码的重复，提高代码的复用性。同时，当需求发生变化，需要添加新的类型或行为时，只需要从基类派生并实现相应的虚函数，而不需要对现有的核心代码进行大规模修改，这大大降低了软件开发和维护的成本。在设计和实现复杂系统时，充分利用多态特性可以使系统的架构更加清晰和健壮。