C++多态：实现面向对象编程中代码灵活性的提升

一、什么是多态

多态(ploymorphism)是C++中面向对象编程的一个重要概念。它指的是通过相同的接口实现不同的功能，也就是同一方法在不同对象上所表现出来的行为不同。多态性是实现面向对象程序设计中代码灵活性的主要手段之一。

C++中实现多态的方式主要有两种，一种是函数重载，另一种是虚函数。函数重载仅仅是根据函数声明的参数数量或类型的不同来进行选择不同的函数实现，而虚函数允许在运行时动态的绑定子类对象的方法，以实现多态。

二、使用虚函数实现多态

在C++中，虚函数的定义方式如下：

class Base {
public:
    // virtual function
    virtual void foo()    {
        std::cout << "Calling Base::foo" << std::endl;
    }
    // non-virtual function
    void bar()    {
        std::cout << "Calling Base::bar" << std::endl;
    }
};

class Derived : public Base {
public:
    // override virtual function
    void foo() override {
        std::cout << "Calling Derived::foo" << std::endl;
    }
    // new non-virtual function
    void baz() {
        std::cout << "Calling Derived::baz" << std::endl;
    }
};

在使用虚函数实现多态的过程中，需要注意以下几点：

1、虚函数必须以virtual关键字开头来进行声明。

2、派生类中重写基类中的虚函数时，必须使用override关键字，这样编译器才能保证正确性。

3、通过基类的指针或引用，可以调用派生类中的虚函数，即根据对象的实际类型动态绑定调用的函数。

例如：

int main() {
    Base* b1 = new Base();
    b1->foo();   // Calling Base::foo
    b1->bar();   // Calling Base::bar
    
    Derived* d1 = new Derived();
    d1->foo();   // Calling Derived::foo
    d1->bar();   // Calling Base::bar
    d1->baz();   // Calling Derived::baz
    
    Base* bd = new Derived();
    bd->foo();   // Calling Derived::foo
    bd->bar();   // Calling Base::bar，同一指针调用不同对象的方法
    // bd->baz(); // 编译错误
}

三、多态的运用场景

在实际的程序中，多态性广泛应用于模板方法模式、装饰模式、迭代器模式等设计模式的实现中。

以装饰模式为例，该模式要求在不修改原有类代码的基础上，增加一些新的行为。使用多态性，可以定义一个基类，其中包含一个虚函数，描述了要添加的特殊行为，而具体的子类可以根据需要来实现这一虚函数，从而达到增加新行为的目的。

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

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

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

class Decorator : public Shape {
protected:
    Shape* m_component;
public:
    Decorator(Shape* component) : m_component(component) {}
};

class RedShapeDecorator : public Decorator {
public:
    RedShapeDecorator(Shape* component) : Decorator(component) {}
    void draw() override {
        m_component->draw();
        std::cout << "Border Color: Red" << std::endl;
    }
};

在以上代码中，使用了装饰模式。Shape定义了一个虚函数draw，表示需要增加的新行为。Rectangle、Circle和Decorator等子类继承了Shape基类，并覆盖了draw函数以实现特殊的行为。最终，RedShapeDecorator作为Decorator的子类，覆盖了draw函数，不仅实现了Shape的draw函数，还增加了新的行为，即打印具体的装饰颜色。