目录
1，什么是多态？
2，什么是虚函数？
1.如何实现父类对各个派生子类的操作？
2，父类指针保存子类空间产生的问题。
3，虚函数的定义
4，虚函数的动态绑定机制
5，重载，重定义，重写的区别
3，纯虚函数
4，虚析构函数
1，纯虚构函数
2，虚析构和纯虚析构的区别
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，函数体必须类外实现，导致父类为抽象类
