1.多态的概念
每逢春节假期，各大娱乐平台都会推出“集卡除夕夜瓜分亿万红包”活动，可同样集卡成功了，有的人红包几块钱，有的人红包却几毛钱......为什么不同的人得到的红包却不相同呢？那是因为平台会根据你的用户数据，比如可能你是新用户、可能你在活动期间活动完成率高......那么你的红包就有可能比别人大一点。
其实这背后就是就是一个多态行为：同样的一个集卡开红包行为，不同的人得到的结果却不相同。
所以多态通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会 产生出不同的状态。
2.多态的定义与实现
2.1多态构成的条件
1中已经说了，多态是在不同继承关系的类对象，去调用同一函数，却产生了不同的行为。比如Unluck_Peo继承了Luck_Peo。Luck_Peo对象的红包是五块，Unluck_Peo对象的红包却是五毛。
那么在继承中要构成多态还有两个条件：
1. 必须通过基类的指针或者引用调用虚函数；
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。
举个例子：
class Luck_Peo { public: virtual void Red_Packet() { cout << "五块红包" << endl; } }; class Unluck_Peo:public Luck_Peo { public: virtual void Red_Packet() { cout << "五毛红包" << endl; } }; void Func(Luck_Peo& p) { p.Red_Packet(); } int main() { Luck_Peo lp; Unluck_Peo up; Func(lp); Func(up); return 0; }
也许到这里还并不能完全理解这段代码的意思，别着急，接下来就让我们了解一下：
2.2虚函数
在上篇文章C++入门11——详解C++继承（菱形继承与虚拟继承）中我们知道，为了解决菱形继承的弊端，C++就引入了虚拟继承，即：被virtual修饰的继承关系成为虚拟继承，相同的道理，虚函数就是被virtual修饰的类成员函数称为虚函数。
举个例子：
class Luck_Peo { public: //virtual修饰成员函数表示虚函数 virtual void Red_Packet() { cout << "五块红包" << endl; } };
2.3虚函数的重写
虚函数的重写(覆盖)：子类中有一个跟父类完全相同的虚函数(即三同：派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了父类的虚函数。
正如我们之前的代码：
class Luck_Peo { public: virtual void Red_Packet() { cout << "五块红包" << endl; } }; class Unluck_Peo:public Luck_Peo { public: virtual void Red_Packet() { cout << "五毛红包" << endl; } }; //*void Red_Packet() { cout << "五毛红包" << endl; } // 注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时， // 其实也是可以构成重写的(因为继承后基类的虚函数被继承下来了，在 // 派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用 void Func(Luck_Peo& p) { p.Red_Packet(); }
虚函数重写的两个例外：
1.协变(基类与派生类虚函数返回值类型不同)
上面已经说了，子类与父类有一个“三同”的虚函数即构成重写。
那么现在我没有构成三同，只构成了两同一不同：
函数名字和参数列表相同，返回值类型不同。其实这也是属于虚函数重写的！
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
举个例子：
class A {}; class B : public A {}; class Person { public: virtual A* f() { return new A; } }; class Student : public Person { public: virtual B* f() { return new B; } };
2.析构函数的重写(基类与派生类析构函数的名字不同)
在C++入门11——详解C++继承（菱形继承与虚拟继承）中，我们已经知道了父类与子类的析构顺序为先子后父：
class Person { public: ~Person() { cout << "~Person()" << endl; } }; class Student:public Person { public: ~Student() { cout << "~Student()" << endl; } }; int main() { Person p; Student s; return 0; }
（如果对此运行结果有疑惑的铁铁，可以查看我的上一篇文章对于C++继承中子类与父类对象同时定义其析构顺序的探究）
现在，我要创建两个父类指针分别指向父类对象和子类对象：
int main() { //Person p; //Student s; Person* p1 = new Person; delete p1; Person* p2 = new Student; delete p2; return 0; }
从运行结果看子类的析构函数并没有被调用，这必然会引起内存泄漏啊！
很明显，这里的调用明显是普通调用：只关注指针、引用、对象的类型；由于两个指针的类型都是Person，所以只调用了Person的析构函数；
而这里我需要的是多态调用：关注指针或引用指向的对象；正确的结果应该是指针指向父类我就调父类的析构函数，指针指向子类我就调用子类的析构函数。
那么如何引发多态呢？上述代码中，我们已经完成了多态构成的条件的第一条，现在的问题无非就是析构函数的重写了呀！
可是虚函数的重写又要保证“三同”，很明显，父类的析构函数名与子类的析构函数名根本不可能相同啊！如何解决这个问题呢？其实在C++入门11——详解C++继承（菱形继承与虚拟继承）提了一嘴：子类的析构函数与父类的析构函数构成隐藏关系，由于多态的原因，析构函数会被特殊处理，函数名都会被处理成destrutor()。
所以析构函数的重写就可以总结为：
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字， 都与基类的析构函数构成重写（为了规范最好父子类都加上virtual）。虽然函数名不相同， 看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处 理，编译后析构函数的名称统一处理成destructor。
规范的代码应该为：
class Person { public: virtual ~Person() { cout << "~Person()" << endl; } }; class Student : public Person { public: virtual ~Student() { cout << "~Student()" << endl; } }; // 只有派生类Student的析构函数重写了Person的析构函数， // 下面的delete对象调用析构函数，才能构成多态， // 才能保证p1和p2指向的对象正确的调用析构函数。 int main() { Person* p1 = new Person; delete p1;//p1->destructor() + operator delete(p1) Person* p2 = new Student; delete p2;//p2->destructor() + operator delete(p2) return 0; }
2.4 C++11 override 和 final
在之前的文章中我们了解到，final修饰的类表示该类为最终类，不能被继承。其实，final除了有这个用处之外还能够修饰虚函数：
C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。
1. final：修饰虚函数，表示该虚函数不能再被重写
class A { public: virtual void Func() final {} }; class B :public A { public: virtual void Func() {} };
2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class A { public: //void Func() {} //error：使用“override”声明的成员函数不能重写基类成员 virtual void Func() {} }; class B :public A { public: virtual void Func() override {} };
2.5 重载、覆盖(重写)、隐藏(重定义)的对比
3.抽象类
抽象这个词近些年成了热梗：这个人真抽象！这个人长得真抽象！当然这些词也都褒贬不一，不过抽象的意思总的来说有被常人不能理解的意思。
那么在C++中，抽象类又是什么呢？
3.1抽象类的概念
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
那么抽象类会用到哪些场景呢？
比如实现一个手机品牌的管理系统：每个手机品牌都有自己的独到之处，那我就把不同手机品牌的基本特征提取出来放到一个公共的类-手机类，然后不同的手机品牌再去继承这个手机类。
在这段描述中，手机类没有实体，不需要实例化出对象，每一个手机品牌类才有对应的有实体，所以手机类应该是抽象的，手机类的这些派生类-手机品牌类才应该是具象的。
举个例子：
#include <iostream> using namespace std; //抽象类 class Phone { public: //纯虚函数 virtual void Trait() = 0; }; class Redmi :public Phone { public: //由于派生类继承了基类，所以派生类也实例化不出对象 //如果想要实例化出对象就必须重写虚函数 //也就是说，抽象类间接地强制了子类重写虚函数 virtual void Trait() { cout << " Redmi-> 性价比之王" << endl; } }; class HuaWei :public Phone { public: virtual void Trait() { cout << " HuaWei->遥遥领先" << endl; } }; int main() { //抽象类实例不出对象 //Phone p; //error:不允许使用抽象类类型“phone”的对象 Phone* p = new Redmi; p->Trait(); p = new HuaWei; p->Trait(); return 0; }
（抽象类具体什么时候用呢？比如在整个体系中我们不期望父类实例化出对象，并且父类的某些函数必须要求其子类重写，这时候就可以考虑用到抽象类）
3.2 接口继承和实现继承（了解一下）
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现；
虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
