C++ - 多态

基本概念

多态的概念，即多种形态。多态分为编译时多态（静态多态）和运行时多态（动态多态）。这里重点讲运行时多态。

编译时多态

主要就是函数重载和函数模板，通过传不同的参数就可以调用不同的函数，通过参数不同达到多态，又因为实参传给形参的参数匹配是在编译时完成的，所以叫编译时多态。

运行时多态

运行时多态允许程序在运行时根据对象的实际类型来调用相应的函数实现，实现的基本原理有三要素

• 虚函数：基类中使用virtual关键字声明的成员函数
• 继承体系：派生类继承自包含虚函数的基类
• 指针/引用调用：通过基类指针或引用调用虚函数

多态的定义及实现

多态的构成条件

多态是一个继承关系下的对象，去调用同一函数，产生了不同的行为。例如：派生类对象Student的基类是Person, 但Person购买火车票的时候是全价购买，而Student购买火车票的时候是打折购买

实现多态的两个重要条件

• 必须是基类的指针或者引用调用虚函数
• 被调用的函数必须是虚函数，并且完成了虚函数的重写/覆盖

要实现多态效果，第一必须是基类的指针或者引用，只有基类的指针或者引用才能指向基类对象又指向派生类对象；第二派生类必须对基类的虚函数完成重写/覆盖，重写/覆盖后基类之间才能有不同函数，才能达到多态的不同效果

虚函数

类成员函数前面加virtual修饰，那么这个成员被称为虚函数。注意非成员函数不能加virtual修饰

class Person
{
public:
    virtual void BuyTicket() cout << "买票-全价" << endl;
};

虚函数的重写/覆盖

派生类中有一个和基类的返回值类型、函数名字、参数列表完全相同的虚函数，称派生类的虚函数重写了基类的虚函数。

注意：在写基类虚函数时，派生类的虚函数在不加virtual关键字时，也可以构成重写。原因是继承后基类的虚函数被继承下来了，在派生类依旧保持虚函数属性，但是写法不规范，不建议这样写。

class Person {
    public:
    virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
    public:
    virtual void BuyTicket() { cout << "买票-打折" << endl; }
};
void Func(Person* ptr)
{
    // 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
    // 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
    ptr->BuyTicket();
}
int main()
{
    Person ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}

补充：协变

派生类重写基类虚函数是，与基类虚函数返回值类型不同。即基类虚函数放回基类对对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变

#include <iostream>
using namespace std;

class A
{
};
class B : public A
{
};
class Person
{
public:
    virtual A *BuyTicket()
    {
        cout << "买票-全价" << endl;
        return nullptr;
    }
};
class Student : public Person
{
public:
    virtual B *BuyTicket()
    {
        cout << "买票-打折" << endl;
        return nullptr;
    }
};
void Func(Person *ptr)
{
    ptr->BuyTicket();
}
int main()
{
    Person ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}

override和final关键字

由于函数名写错参数等导致无法构成重写，这种错误编译是不会报错的，只有在程序运行时没有得到预期结果才会发现，所以C++11提供了override，可以帮助检测是否重写。如果不想让派生类重写该虚函数，也可以用final修饰

override

#include <iostream>
using namespace std;

class Car
{
public:
    virtual void Dirve()
    {
    }
};
class Benz : public Car
{
public:
    //	   基类是Dirve()
    virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
    return 0;
}

final

class Car
{
public:
    virtual void Drive() final {}
};
class Benz : public Car
{
public:
    virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{
    return 0;
}

重载/重写/隐藏的对比

纯虚函数和抽象类

在虚函数的后⾯写上 =0，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没意义因为就算实现派⽣类也要重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了派⽣类重写虚函数，因为不重写实例化不出对象

#include <iostream>
using namespace std;

class Car
{
public:
    virtual void Drive() = 0;
};
class Benz : public Car
{
public:
    virtual void Drive()
    {
        cout << "Benz-舒适" << endl;
    }
};

class BMW : public Car
{
public:
    virtual void Drive()
    {
        cout << "BMW-操控" << endl;
    }
};
int main()
{
    // 编译报错：error C2259: “Car”: ⽆法实例化抽象类
    Car car;
    Car *pBenz = new Benz;
    pBenz->Drive();
    Car *pBMW = new BMW;
    pBMW->Drive();
    return 0;
}