day5 5.1多态

多态的概念

C++ 多态与虚函数，多态（Polymorphism）是面向对象（Object-Oriented，OO）思想”三大特征”之一，其余两个分别是封装（Encapsulation）和继承（Inheritance）–可见多态的重要性；或者说，不懂得什么是多态就不能说懂得面向对象；
多态是一种机制、一种能力，而非某个关键字；它在类的继承中得以实现，在类的方法调用中得以体现；

在之前的继承与派生中，我们讲到这么个例子：

#include <cstdio>
using namespace std;

class People {
public:
    People(const char *name, int age);
    void print() const;
protected:
    const char *m_name;
    int m_age;
};

People::People(const char *name, int age) : m_name(name), m_age(age) {}
void People::print() const {
    printf("name: %s, age: %d\n", m_name, m_age);
}

class Student : public People {
public:
    Student(const char *name, int age, float score);
    void print() const;
private:
    float m_score;
};

Student::Student(const char *name, int age, float score) : People(name, age), m_score(score) {}
void Student::print() const {
    printf("name: %s, age: %d, score: %g\n", m_name, m_age, m_score);
}

int main() {
    People *p = nullptr;// vs、vc新标准空指针
    p = new People("ZhangSan", 25);
    p -> print();
    delete p;

    p = new Student("LiSi", 14, 87.5f);
    p -> print();
    delete p;
    return 0;
}

运行结果:
name: ZhangSan, age: 25
name: LiSi, age: 14

我们直观上认为，如果指针指向了派生类对象，那么就应该使用派生类的成员变量和成员函数，这符合人们的思维习惯；
但是本例的运行结果却告诉我们，当基类指针 p 指向派生类 Student 的对象时，虽然使用了 Student 的成员变量，但是却没有使用它的成员函数，导致输出结果不伦不类，不符合我们的预期；

换句话说，通过基类指针只能访问派生类的成员变量，但是不能访问派生类的成员函数；

为了消除这种尴尬，让基类指针能够访问派生类的成员函数，C++ 增加了虚函数（Virtual Function）；使用虚函数非常简单，只需要在函数声明前面增加virtual关键字；

更改上面的代码，将 print() 声明为虚函数：

#include <cstdio>

using namespace std;

class People {
public:
    People(const char *name, int age);
    virtual ~People() {}//虚析构函数，在继承里，方便回收动态内存
    virtual void print() const;//虚函数，成员函数，声明一次
protected:
    const char *m_name;
    int m_age;
};

class Student : public People {
public:
    Student(const char *name, int age, float score);
    virtual ~Student() override {}
    virtual void print() const override;
private:
    float m_score;
};

People::People(const char *name, int age) : m_name(name), m_age(age) {}
void People::print() const {
    printf("name: %s, age: %d\n", m_name, m_age);
}

Student::Student(const char *name, int age, float score) : People(name, age), m_score(score) {}
void Student::print() const {
    printf("name: %s, age: %d, score: %g\n", m_name, m_age, m_score);
}

int main() {
    People *p = nullptr;

    p = new People("ZhangSan", 25);
    p -> print();
    delete p;

    p = new Student("LiSi", 14, 87.5);
    p -> print();
    delete p;

    return 0;
}

运行结果：
name: ZhangSan, age: 25
name: LiSi, age: 14, score: 87.5

override是 C++11 中新增的关键字，override确保在派生类中声明的重载函数跟基类的虚函数有相同的签名；

有了虚函数，基类指针指向基类对象时就使用基类的成员（包括成员函数和成员变量），指向派生类对象时就使用派生类的成员；换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为多态（Polymorphism）；

多态是面向对象编程的主要特征之一，C++中虚函数的唯一用处就是构成多态；

C++提供多态的目的是：可以通过基类指针对所有派生类（包括直接派生和间接派生）的成员变量和成员函数进行“全方位”的访问，尤其是成员函数；如果没有多态，我们只能访问成员变量；

前面我们说过，通过指针调用普通的成员函数时会根据指针的类型（通过哪个类定义的指针）来判断调用哪个类的成员函数，但是通过本节的分析可以发现，这种说法并不适用于虚函数，虚函数是根据指针的指向来调用的，指针指向哪个类的对象就调用哪个类的虚函数；

借助引用也可以实现多态

引用在本质上是通过指针的方式实现的，既然借助指针可以实现多态，那么我们就有理由推断：借助引用也可以实现多态；
修改上面的 main() 函数：

int main() {
    People p("ZhangSan", 25);
    Student s("LiSi", 14, 87.5);

    People &rp = p;
    People &rs = s;
    rp.print();
    rs.print();

    return 0;
}

运行结果：
name: ZhangSan, age: 25
name: LiSi, age: 14, score: 87.5

不过引用不像指针灵活，指针可以随时改变指向，而引用只能指代固定的对象，在多态性方面缺乏表现力，所以以后我们再谈及多态时一般是说指针；本例的主要目的是让读者知道，除了指针，引用也可以实现多态；