1、什么是虚函数
　　在基类中用virtual关键字修饰，并在一个或多个派生类中被重新定义的成员函数，用法格式为：
　　virtual　函数返回类型　函数名（参数表）
　　 {
　　 　函数体
　　 }
　　 虚函数是实现多态性的关键，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。
　　
看两个例子：
①没有定义基类的Fun函数为虚函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:void Fun(){cout << "Base::Fun()" << endl;}
private:int data;
};class Derived : public Base
{
public:void Fun(){cout << "Derived::Fun()" << endl;}
private:int data;
};int main()
{Derived d;Base* pb = &d;pb->Fun();return 0;
}

可以看到此时基类指针虽然指向的是派生类，但仍然调用的是基类的Fun函数。

②定义了基类的Fun函数为虚函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:virtual void Fun()     //注意这儿加了关键字virtual{cout << "Base::Fun()" << endl;}
private:int data;
};class Derived : public Base
{
public:void Fun(){cout << "Derived::Fun()" << endl;}
private:int data;
};int main()
{Derived d;Base* pb = &d;pb->Fun();return 0;
}

可以看到此时基类指针指向派生类后，其调用Fun函数时就是调用派生类的Fun函数了，从这儿也能看出虚函数是实现多态的关键。

2、虚函数的实现
①在基类中用virtual关键字修饰成员函数，使之成为一个虚函数，在派生类中重写该函数，使之完成新的功能。

②派生类中重写该虚函数时，要求重写的函数的函数名、参数列表、返回值都与基类虚函数相同，函数体根据需要选择是否重写。若不重写，则直接完成继承于基类。
PS：C++规定，当一个成员函数被定义为虚函数时，其派生类中的同名函数都自动变为虚函数，因此，派生类在重新定义该虚函数时，可加virtual关键字，也可以不加，但为了层次的清晰与代码的易读性，最好还是加上（那感觉前面说的都是废话）。

③定义一个基类的指针，使之指向同一类族中需要调用的函数所在类的对象。
PS：基类与派生类的赋值关系可以参考下面这篇博客中的第六条：
http://blog.csdn.net/ljx_5489464/article/details/51114534

④通过该指针调用虚函数，此时调用的就是指针指向的对象的同名函数了。

用一个实例来说明上述实现机制：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:virtual void Fun()     //加virtual关键字{cout << "Base::Fun()" << endl;}
private:int data;
};class Derived : public Base
{
public:void Fun(){//重写Fun函数的函数体，当然，这儿不是必须要重写的cout << "Derived::Fun()" << endl;}
private:int data;
};class Derived_Derived : public Derived
{
public:void Fun(){//重写Fun函数的函数体，当然，这儿不是必须要重写的cout << "Derived_Derived::Fun()" << endl;}
private:int data;
};int main()
{Derived_Derived d;Derived* pb = &d;pb->Fun();return 0;
}

我在Derived类中并没有在Fun函数前加virtual关键字，但pb指针调用的却是Derived_Derived类中的Fun函数，而非Derived类中的，这就说明了只要基类的成员函数被定义为虚函数时，派生类的同名函数就会变为虚函数。

注意：虚函数只能出现在类的继承层次中，只能定义类的成员函数为虚函数，不能定义类外的普通函数为虚函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;virtual void Fun()     //注意这儿加了关键字virtual
{cout << "Base::Fun()" << endl;
}int main()
{Fun();return 0;
}

以上代码会报错：

3、虚析构函数
　　析构函数执行时先调用派生类的析构函数，其次才调用基类的析构函数。如果析构函数不是虚函数，而程序执行时又要通过基类的指针去销毁派生类的动态对象（用new运算符创建的），那么用delete销毁对象时，只调用了基类的析构函数，未调用派生类的析构函数。这样会造成销毁对象不完全。

看例子：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <iostream> 
using namespace std; class Base 
{ 
public: Base(){ cout << "Base()" << endl; }~Base() {cout << "~Base()" << endl; } 
private: int data; 
};class Derived: public Base 
{
public: Derived(){cout << "Derived()" << endl;}~Derived(){cout << "~Derived()" << endl;}
private: int data;
}; int main()
{ Base *pb = new Derived;delete pb; return 0; 
}

可以看到，确实是只调用了基类的析构函数，派生类的析构函数并没有被调用。

当我把基类的析构函数改成这样：

virtual ~Base() 
{cout << "~Base()" << endl;
} 

再运行时，结果如下：

可以看到，此时不管是基类还是派生类的的析构函数都被调用了，为什么呢？
解析如下：
假设Derive类public继承自Base类，并且基类的析构函数没有定义为虚函数，有如下调用：
Base* pb = new Derive；
delete pb；
这时候，delete pb时，编译器会把pb当成Base的一个对象看待，因为pb是Base类型的，所以直接去调用基类的析构函数；
若将基类的析构函数写成virtual函数，那么基类和派生类的析构函数会分别存放在自己的虚表中，这时再执行delete pb时，会调用析构函数，但现在虚构函数是虚函数，所以会到虚表中去查找，而此时pb指向的刚好是一个派生类对象，所以通过虚表查找就找到了派生类的虚函数，从而调用派生类的析构函数。

4、纯虚函数
①定义：
　　纯虚函数是在基类中声明的虚函数，它在基类中没有定义，即没有函数体，但要求任何派生类都要实现自己的函数体。在基类中实现纯虚函数的方法是在函数原型后加“=0;“。
virtual void funtion()=0 ;

②引入原因 ：
　　为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。 但在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。 为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数，则编译器要求在派生类中必须予以重写以实现多态性。这样就很好地解决了上述两个问题。

③作用：
　　纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对其进行实现，从而实现多态性。

④抽象类
　　不用来定义对象，只是作为一种基本类型用作继承的类，称为抽象类，由于抽象类通常作为基类，所以也称为抽象基类。包含纯虚函数的类就是抽象类，它不能生成对象。

注意：
①纯虚函数没有函数体；
②纯虚函数声明形式最后的“=0;”并不是返回值是0，它只是起一个形式上的作用，告诉编译器这是虚函数；
③虚函数的声明形式是一个语句，最后要加上“;”。
④纯虚函数只有声明，没有函数体，所以它不具有函数功能，因此不能被调用，可以称其为“徒有其表”。
⑤如果一个类中声明了虚函数，且在其派生类中没有被实现，那么在派生类中它仍为纯虚函数。

最后用一个实例来剖析：

class Animal
{
public:virtual void Sleep() = 0;   //这里声明Sleep为纯虚函数
public:char sex[5];int age;
};class Person: public Animal
{
public:virtual void Sleep(){cout << "Person lying down to sleep!" << endl;}
public:char notionality[20];   //国籍char name[10];
};class Horse: public Animal
{
public:virtual void Sleep(){cout << "Horse sleep standing up!" << endl;}
public:char rase[20];          //种族
};int main()
{Animal a;return 0;
}

此时用含有纯虚函数Sleep的抽象类Animal来创建对象时，会报错。

我把主函数改为调用抽象类Animal中的Sleep函数：

int main()
{Animal::Sleep();return 0;
}

调用一个纯虚函数，会报错。

我把Person修改了，去掉它对Sleep函数的实现：

class Person: public Animal
{
public:char notionality[20];   //国籍char name[10];
};

此时Person类中没有对Sleep函数进行实现，因此，Person类中的Sleep函数仍为虚函数，会报错。