一、多态的概念
多态简单来说就是多种形态。多态又分为编译时多态（静态多态）和运行时多态（动态多态）。编译时多态(静态多态)主要就是我们一般讲的函数重载和函数模板。运行时多态，具体点就是去完成某个行为(函数)，可以传不同的对象就会完成不同的行为，就达到多种
形态。就像我们买火车票一样，普通人买的是成人票而学生买票有优惠（五折或七五折）。
二、多态的定义和实现
1.多态的构成条件
多态是⼀个继承关系的下的类对象，去调用同⼀函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象优惠买票。
实现多态还有两个必须重要条件：
• 必须指针或者引用调用函数。（后面会叙述什么是虚函数）• 被调用的函数必须是虚函数。
2.虚函数
类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加virtual修饰。
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};3.虚函数的重写
虚函数的重写/覆盖：子类中有⼀个跟父类完全相同的虚函数(即子类虚函数与父类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了父类的虚函数。
注意：在重写父类虚函数时，子类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后父类的虚函数被继承下来了在子类依旧保持虚函数属性)。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-打折" << endl; }
};4.协变
子类重写父类虚函数时，与父类虚函数返回值类型不同。即父类虚函数返回父类对象的指针或者引用，子类虚函数返回子类对象的指针或者引用时，称为协变。
#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;
}
5.析构函数的重写
父类的析构函数为虚函数，此时子类析构函数只要定义，无论是否加virtual关键字，都与父类的析构函数构成重写，虽然父类与子类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以父类的析构函数加了vialtual修饰，子类的析构函数就构成重写。
下面的代码我们可以看到，如果~A()，不加virtual，那么delete p2时只调用的A的析构函数，没有调用B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。
#include<iostream>
using namespace std;
class A
{
public:
virtual ~A()
{
cout << "~A()" << endl;
}
};
class B : public A {
public:
~B()
{
cout << "~B()->delete:" << _p << endl;
delete _p;
}
protected:
int* _p = new int[10];
};
// 只有⼦类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能构
//成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
int main()
{
A* p1 = new A;
A* p2 = new B;
delete p1;
delete p2;
return 0;
}6.override和 final关键字
C++对函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数写
错等导致无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果，才来debug会得不偿失，因此C++11提供了override，可以帮助用户检测是否重写。如果我们不想让子类重写这个虚函数，那么可以用final去修饰。
class Car {
public:
virtual void Dirve()
{}
};
class Benz :public Car {
public:
virtual void Drive() override { cout << "Benz-舒适" << endl; }
// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何⽗类⽅法
};
int main()
{
return 0;
}// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}7.重载、重写/覆盖、隐藏的对比
三、抽象类
在虚函数的后面写上 =0 ，则这个函数为纯虚函数，纯虚函数不需要定义实现，只要声明即可 。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果子类继承后不重写纯虚函数，那么子类也是抽象类。纯虚函数某种程度上强制了子类重写虚函数，因为不重写实例化不出对象。
#include<iostream>
using namespace std;
class Car
{
public:
virtual void Drive() = 0;
};
int main()
{
// 编译报错：error C2259: “Car”: ⽆法实例化抽象类
Car car;
return 0;
}四、多态的原理
1.虚函数表指针
多态能实现的关键因素就是编译器在实现虚函数时，会给每个对象加一个隐藏成员。隐藏成员中保存了一个指向函数地址数组的指针。这个数组被称为虚函数表，这个指针则是虚函数指针。
2.多态的实现原理
看下面代码：
#include<iostream>
using namespace std;
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-打折" << endl; }
};
class Soldier : 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;
Soldier sr;
Func(&ps);
Func(&st);
Func(&sr);
return 0;
}
我们可以看监视窗口，不同对象的虚函数指针指向的是与自己相对应函数地址。多态的实现其实靠的虚函数指针，就如上述代码，Func(&ps)函数调用时它会根据虚函数指针提供的地址调用对应的函数，从而实现多态。
3.动态绑定与静态绑定
对不满足多态条件(指针或者引用+调用虚函数)的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做动态绑定。
4.虚函数表
1.父类对象的虚函数表中存放父类所有虚函数的地址。
2.子类由两部分构成，继承下来的父类和自己的成员，⼀般情况下，继承下来的父类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意的这里继承下来的父类部分虚函数表指针和父类对象的虚函数表指针不是同⼀个，就像父类对象的成员和子类对象中的父类对象成员也独⽴的。
3.子类中重写的父类的虚函数，子类的虚函数表中对应的虚函数就会被覆盖成⼦类重写的虚函数地
址。
4. 子类的虚函数表中包含，父类的虚函数地址，子类重写的虚函数地址，子类自己的虚函数地址三个部分。
5.虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后面放了⼀个0x00000000标记。