1，什么是多态？
多态是指同样的消息被不同类型的对象界首市导致的不同行为，所谓小学时只对类的成员函数调用，不同的行为是指不同的实现，也就是调用了不同的函数。多态性提供接口与具体实现之间的另一层隔离，同时创建了使程序具有扩展性。事实上在程序设计中经常使用多态，的特性，最近简单的例子就是运算符对不同类型的数据对象运算。
多态的类型一般分为两类：
静态多态（编译时多态，早绑定）：函数重载、运算符重载、重定义
动态多态（运行时多态，晚绑定）：虚函数 父类指针（引用）保存 子类空间地址的目的 就是让算法通用。
2，什么是虚函数？
1.如何实现父类对各个派生子类的操作？
这里的操作是在继承父类成员的条件下，对子类继承的成员的操作，也就是调用
首先要实现父类对各个派生子类的操作，我们需要父类指针保存子类空间，利用这个方式实现父类算法通用。
总结：通过构建父类指针保存子类的空间，实现对各个子类的操作（实际上这里还并不行，但这是实现该功能的前提）！
在这个基础上，构建虚函数或者纯虚函数他才会成立，在主函数中有应当如何去调用，都是父类指针保存子类空间的这个前提！！
2，父类指针保存子类空间产生的问题。
我们的目的是需要操作各个子类，虽然实现了如何访问哥哥派生子类，但实际上还并未能操作子类。
例：
#include<iostream> using namespace std; class animal { public: void nameshow() { cout << "我是什么动物" << endl; } }; class cat :public animal { public: void nameshow() { cout << "我是猫" << endl; } }; int main() { //通过父类指针保存子类空间，实现对各个派生类的操作 animal* p = new cat; //但我们这里想要调用的是子类的成员，但结果是父类的成员 p->nameshow(); return 0; }
由上例知道，通过父类指针保存子类空间是没问题的，但因为你是父类指针，调用时不是操作子类，而是父类，故还并未实现父类对子类的操作，此时我们在定义父类成员（一般为函数）时就添加了关键词virtual，也就是虚函数，引入虚函数，我们可以实现父类对子类的调用。
3，虚函数的定义
父类成员函数前加virtual修饰。
#include<iostream> using namespace std; class animal { public: virtual void nameshow() { cout << "我是什么动物" << endl; } }; class cat :public animal { public: void nameshow() { cout << "我是猫" << endl; } }; class dog :public animal { public: void nameshow() { cout << "我是狗" << endl; } }; int main() { //通过父类指针保存子类空间，实现对各个派生类的操作 animal* p1 = new cat; animal* p2 = new dog; //成功调用 p1->nameshow(); p2->nameshow(); return 0; }
通过关键词virtual我们将成员函数定义为虚函数，此时父类指针指向子类空间时，我们调用的就是子类的这个成员函数。
多态条件：有继承、子类重写父类的虚函数，父类指针 指向子类空间。
我们可将子类继承父类的成员当做链接父类与子类的桥梁，父类指针指向各个子类空间就是实现各个桥梁，virtual就是实现父类通过桥梁到子类。
4，虚函数的动态绑定机制
当类中的成员函数被virtual修饰，那么这个函数就是虚函数，并且就会产生一个虚函数指针，指向了一张虚函数表（vftable），如果这个函数没有涉及到继承，这时虚函数表中记录着当前虚函数入口地址。
此时子类如dog：
可以看到子类会把父类的虚函数指针继承过来，同时把虚函数表继承过来，但虚函数表会被重写，可以看到上图中的表发生了改变，此时入口地址也发生了改变，此时调用时因为索引（地址）发生了改变，故调用的是子类的中的成员函数。
5，重载，重定义，重写的区别
重载：同一作用域，同名函数，参数的顺序、个数、类型不同 都可以重载。函数的返回值类型不能作为 重载条件（函数重载、运算符重载）。
重定义：有继承，子类 重定义 父类的同名函数（非虚函数）， 参数顺序、个数、类型可以不同。子类 的同名函数会屏蔽父类的所有同名函数（可以通过作用域解决）。
重写（覆盖）：有继承，子类 重写 父类的虚函数。返回值类型、函数名、参数顺序、个数、类型都必须 一致。
3，纯虚函数
我们可以发现如果基类一定派生出子类，而子类一定会重写父类的虚函数，也就是子类函数有自己的功能，那么父类的虚函数中的函数体感觉是无意义（我们既不需要调用它，在设计时他也是一个一个模糊的函数），那么可不可以不写父类虚函数的函数体呢？当然是可以的，而这就是纯虚函数。
纯虚函数的定义方式:
class 父类名 { public: //纯虚函数 virtual void speak(void)=0; };
我们以一个实现对各个形状面积的计算的纯虚函数来实现。
include<iostream> using namespace std; class Shape { public: //定义纯虚函数 virtual double Getarea(void)=0; //也可以定义虚函数virtual double Getarea(void){return 0;} void print() { cout<<"调用基类对象的成员函数"<<endl; } }; class Rectangle:public Shape { public: void print() { cout<<"调用派生类对象（Rectangle）的成员函数"<<endl; } Rectangle(double x,double y) { Length=x; Width=y; } double Getarea() { return Length*Width; } private: double Length,Width; }; class Circle:public Shape { public: void print() { cout<<"调用派生类对象（Circle）的成员函数"<<endl; } Circle(double x) { Radious=x; } double Getarea() { return 3.14*Radious*Radious; } private: double Radious; }; int main() { Shape *p1=new Rectangle (2.2,2.0); Shape *p2=new Circle (1.0); cout<<"矩形面积为"<<p1->Getarea()<<endl; cout<<"圆面积为："<<p2->Getarea()<<endl; return 0; }
有纯虚函数的类我们称作抽象类，对于抽象类是无法实例化对象的。
这里shape a；就会报错，已经无法实现实例化对象。
虚函数和纯虚函数的区别：
虚函数：virtual修饰 有函数体 不会导致父类为抽象类。
纯虚函数：virtual修饰，=0，没有函数体 导致父类为抽象类。子类必须重写父类的所有纯虚函数。
4，虚析构函数
顾名思义，就是虚函数的析构函数。
因为之前我们在上例中都是用new开辟一个子类的空间，我们是在堆区上开辟的，若不释放就会造成内存泄漏。
如这里的animal*p=new cat;
delete p；
而在这里释放时直接delete这个父类指针，但是我们存放的是子类的空间，却是父类类型，故释放的应该是子类中属于父类的这一部分空间，但事实上我们new的是整个子类空间，因此在析构时只会调用父类中的析构，与子类无关，因此释放不彻底，有部分内存存在泄漏的可能。
那么如何去释放父类指针中的所有空间，这时候我们还是添加virtual，实现对父类指针中子类空间的全部释放，这就是虚析构。此时调用就会父类与子类的析构都会调用。
#include<iostream> using namespace std; class animal { public: animal() { cout << "调用父类构造" << endl; } virtual void nameshow() { cout << "我是什么动物" << endl; } ~animal()//virtual ~animal() { cout << "调用父类析构" << endl; } }; class cat :public animal { public: cat() { cout << "调用cat构造" << endl; } void nameshow() { cout << "我是猫" << endl; } ~cat() { cout << "调用cat析构" << endl; } }; class dog :public animal { public: dog() { cout << "调用dog构造" << endl; } void nameshow() { cout << "我是狗" << endl; } ~dog() { cout << "调用dog析构" << endl; } }; int main() { //通过父类指针保存子类空间，实现对各个派生类的操作 animal* p1 = new cat; animal* p2 = new dog; //但我们这里想要调用的是子类的成员，但结果是父类的成员 p1->nameshow(); p2->nameshow(); //释放空间，调用析构 delete p1; delete p2; return 0; }
这里未调用子类析构，可知这一部分空间未被删除，添加关键字virtual后：
可以发现父类保存的子类空间全部被释放掉。
1，纯虚构函数
纯虚析构函数的定义：
纯虚析构的本质：是析构函数，各个类的回收工作。而且析构函数不能被继承， 必须为纯虚析构函数提供一个函数体。（而纯虚函数是没有函数体的）
纯虚析构函数： 必须在类外实现.
例：
class animal { public: animal() { cout << "调用父类构造" << endl; } virtual void nameshow() { cout << "我是什么动物" << endl; } //纯虚析构函数 virtual ~animal(void) = 0; }; animal::~animal() { cout << "调用父类析构" << endl; } class cat :public animal { public: cat() { cout << "调用cat构造" << endl; } void nameshow() { cout << "我是猫" << endl; } ~cat() { cout << "调用cat析构" << endl; } }; class dog :public animal { public: dog() { cout << "调用dog构造" << endl; } void nameshow() { cout << "我是狗" << endl; } ~dog() { cout << "调用dog析构" << endl; } }; int main() { //通过父类指针保存子类空间，实现对各个派生类的操作 animal* p1 = new cat; animal* p2 = new dog; //但我们这里想要调用的是子类的成员，但结果是父类的成员 p1->nameshow(); p2->nameshow(); //释放空间，调用析构 delete p1; delete p2; return 0; }
这样的书写方式就是纯虚析构函数的实现，作用与上述虚析构函数的作用相同，两者都释放了父类和子类的空间，析构也都调用了。
2，虚析构和纯虚析构的区别
虚析构：virtual修饰，有函数体，不会导致父类为抽象类。
纯虚析构：virtual修饰，=0，函数体必须类外实现，导致父类为抽象类
