C++面向对象之多态的实现和应用详解

什么是多态

多态是指通过基类指针或引用调用不同派生类中同名的虚函数时，会根据对象的实际类型执行相应的实现。通过多态可以达到一种动态绑定的效果，提高了代码的灵活性和可扩展性。

多态的实现

在C++中，使用虚函数实现多态。虚函数是一种特殊的成员函数，通过在基类中声明为虚函数，可以让派生类重写该函数并使用动态绑定的方式调用。

以下是一个简单的示例：

class Shape {    // 基类
public:
    virtual void draw() {    // 声明为虚函数
        cout << "Drawing a shape." << endl;
    }
    // ...
};

class Circle : public Shape {
public:
    void draw() {    // 重写基类的虚函数
        cout << "Drawing a circle." << endl;
    }
    // ...
};

class Triangle : public Shape {
public:
    void draw() {    // 重写基类的虚函数
        cout << "Drawing a triangle." << endl;
    }
    // ...
};

int main() {
    Shape* s1 = new Circle();
    Shape* s2 = new Triangle();
    s1->draw();    // 动态绑定，执行 Circle 的实现
    s2->draw();    // 动态绑定，执行 Triangle 的实现
    // ...
    return 0;
}

上述示例中，基类 Shape 提供了一个名为 draw 的虚函数，其派生类 Circle 和 Triangle 分别重写了该函数，并提供了不同的实现。在 main 函数中，通过基类指针 s1 和 s2 分别指向了不同类型的对象，再通过 s1->draw() 和 s2->draw() 调用函数时，使用了动态绑定的方式，执行了相应的子类实现。

多态的应用

多态在实际应用中非常广泛，以下是两个示例：

示例一：共性抽象，个性定制

在一个图形绘制软件中，不同的图形（圆形、三角形、矩形等）都具有一些共性特点，比如都可以执行 draw 函数来绘制图形。但又各自具备一些特殊的属性和方法（比如圆形具有半径属性）。此时可以使用多态的思想，将这些图形都看作是一种 Shape，而具体的特性则由各自的派生类来决定。

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

class Circle : public Shape {
private:
    int radius;
public:
    void draw() {    // 重写基类的纯虚函数
        cout << "Drawing a circle with radius " << radius << endl;
    }
    // ...
};

class Triangle : public Shape {
private:
    int a, b, c;    // 三边长
public:
    void draw() {    // 重写基类的纯虚函数
        cout << "Drawing a triangle with length " << a << ", " << b << " and " << c << endl;
    }
    // ...
};

int main() {
    Shape* s1 = new Circle();
    Shape* s2 = new Triangle();
    s1->draw();    // 动态绑定，执行 Circle 的实现
    s2->draw();    // 动态绑定，执行 Triangle 的实现
    // ...
    return 0;
}

上述示例中，基类 Shape 声明了一个纯虚函数 draw，其派生类 Circle 和 Triangle 分别实现了该函数，并提供了各自的特有属性。在 main 函数中，通过基类指针 s1 和 s2 分别指向了不同类型的对象，再通过 s1->draw() 和 s2->draw() 调用函数时，使用了动态绑定的方式，执行了相应的子类实现。

示例二：接口隔离，封装变化

在一个音乐播放器中，不同的格式歌曲（MP3、WAV、FLAC等）都需要进行播放和停止操作。此时可以使用多态的思想，将这些歌曲都看作是一种 Music，而具体的格式实现则由各自的派生类来决定。通过将操作音乐文件的功能进行抽象，使用统一的接口，使得系统扩展或修改某种格式的音乐文件时，只需要修改对应的派生类，而不需要修改整个系统代码。

class Music {    // 基类
public:
    virtual void play() = 0;    // 纯虚函数
    virtual void stop() = 0;    // 纯虚函数
    // ...
};

class MP3 : public Music {
public:
    void play() {    // 重写基类的纯虚函数
        cout << "Playing MP3 music." << endl;
    }
    void stop() {    // 重写基类的纯虚函数
        cout << "Stop playing MP3 music." << endl;
    }
    // ...
};

class WAV : public Music {
public:
    void play() {    // 重写基类的纯虚函数
        cout << "Playing WAV music." << endl;
    }
    void stop() {    // 重写基类的纯虚函数
        cout << "Stop playing WAV music." << endl;
    }
    // ...
};

int main() {
    Music* m1 = new MP3();
    Music* m2 = new WAV();
    m1->play();    // 动态绑定，执行 MP3 的实现
    m2->play();    // 动态绑定，执行 WAV 的实现
    // ...
    return 0;
}

上述示例中，基类 Music 声明了两个纯虚函数 play 和 stop，其派生类 MP3 和 WAV 分别实现了这两个函数，并提供了各自的特有属性。在 main 函数中，通过基类指针 m1 和 m2 分别指向了不同类型的对象，再通过 m1->play() 和 m2->play() 调用函数时，使用了动态绑定的方式，执行了相应的子类实现。