C++ 多态的实例

这是我从书中摘录的觉得非常不错的实例。

1. 基本知识

1.1 多态的概念

简单理解为：同一个接口，多种实现方式。对不同类的对象发出相同的消息的时候，会产生不同的行为。

1.2 多态的作用

（1）应用程序可以不必为每一个派生类编写功能调用，而只需要对抽象基类进行处理即可，实现代码的可重用；

（2）派生类的功能可以被基类的方法或引用变量所调用，这称作向后兼容，

2. 多态的实现

多态分为动态多态、静态多态、函数多态和不太常见的宏多态，编程者的多态通常是指动态多态，是基于继承机制和虚函数实现的。

2.1 多态的实例

下面是多态的实例代码：

#include <iostream>

using namespace std;

class Bird {
public:
    virtual void fly() {
        cout << "Bird can fly" << endl;
    }
};

class Duck:public Bird {
public:
    void fly() {
        cout << "Duck can't fly" << endl;
    }
};

class Chicken :public Bird {
public:
    void fly() {
        cout << "Chicken can't fly" << endl;
    }
};

int main(void) {

    Bird* birdOne = new Duck;
    birdOne->fly();
    Bird* birdTwo = new Chicken;
    birdTwo->fly();
    Bird birdThree;
    birdThree.fly();

    return 0;
}

子类Duck和Chicken都派生与父类Bird的虚函数fly，它们有相同的接口fly，但是能够表现出两种不同的行为。

2.2 动态多态实例

#include <iostream>

using namespace std;

class Vehicle {
public:
    virtual void run() const= 0;
};

class Car:public Vehicle {
public:
    void run() const{
        cout << "run a car" << endl;
    }
};

class Airplane :public Vehicle {
public:
    void run() const {
        cout << "run a airplane" << endl;
    }
};

void run_vehicle(const Vehicle *test) {
    test->run();
}

int main(void) {
    Car car;
    Airplane airplane;
    run_vehicle(&car);
    run_vehicle(&airplane);
    return 0;
}

通过定义抽象基类来定义派生类方法的虚函数，客户程序可以通过指向基类的指针来使用具体对象。这里注意指向基类的指针使用const时，其他部分应该如何定义。

2.3 静态多态的实例

#include <iostream>

using namespace std;

class Car {
public:
    void run()const {
        cout << "run a car" << endl;
    }
};

class Airplane {
public:
    void run() const {
        cout << "run a airplane" << endl;
    }
};

template <typename Vehicle>
void run_vehicle(const Vehicle &test) {
    test.run();
}

int main(void) {
    Car car;
    Airplane airplane;
    run_vehicle(car);
    run_vehicle(airplane);
    return 0;
}

在这里Vehicle编程了模板参数，而非公共基类，通过编译器处理后，得到的是run_vehicle<Car>()和run_vehicle<Airplane>()两个不同的函数。静态多态为C++引入了泛型编程的概念。

2.4 函数多态的实例

#include <iostream>
#include <string>
using namespace std;

int my_add(int a, int b) {
    return a + b;
}

int my_add(int a, string b) {
    return a + atoi(b.c_str());
}

int main(void) {
    int i = my_add(1, 2);
    int s = my_add(1, "2");
    cout << "i = " << i << endl;
    cout << "s = " << s << endl;
    return 0;
}

函数多态是常说的重载，基于不同的函数参数列表，相同的函数名称可以指向不同的函数定义。

2.5 宏多态的实例

#include <iostream>
#include <string>
using namespace std;

#define ADD(a, b) ((a)+(b))

int main(void) {
    int i = ADD(2, 3);
    string s1("hello "), s2("world");
    string s = ADD(s1, s2);
    cout << i << endl;
    cout << s << endl;
    return 0;
}

带变量的宏实现的是一种初级的静态多态，在这里编译器将宏参数直接替换，在C++中数值和字符串都是可以做相加运算的，所以直接替换能够生效。