刚开始学习C++虚函数的时候，只知道虚函数就是用来构成动态多态的，以及如何使用虚函数。但是我发现当碰到稍微复杂的多态问题的时候，就很难以理解其实现原理，导致使用出错，比如：一个派生类继承基类，生成派生类对象有两种方式：调用基类指针生成对象、调用派生类指针生成对象，调用完毕后释放对象，哪种方式必须要用虚函数实现基类和派生类的析构函数，如果不用会出现什么问题？（可移步基类的析构函数是否要定义为虚函数）。而《C++ Primer》中更多的是对虚函数使用的讲解，查阅有关虚函数实现多态的博客也大都千篇一律，这对学习者从底层理解虚函数实现多态的原理帮助甚微。本文将从内存角度上剖析一下虚函数实现多态的底层原理，希望能给C++学习者提供帮助。

一、无继承时，含虚函数类的内存布局剖析

无继承的类中定义虚函数实际上没有意义的，因为虚函数存在的意义就是为了实现动态多态，即将虚函数看作一个接口去调用基类和派生类中同一个函数实现不同的功能。但是为了更好地展示从无继承到有继承时虚函数引起的内存布局变化情况，这里首先定义一个无继承类进行分析。

class Base
{
public:
	virtual void fun1() {};
	virtual void fun2() {};
	virtual void fun3() {};
	void fun4() {};

private:
	int m_A;
	int m_B;
};

在vs2013中完成类定义后，选择“项目—>属性—>C/C++命令行—>其他选项”，在这里写上/d1 reportSingleClassLayoutBase，然后生成解决方案，输出行就会显示Base类的内存布局，如下图所示：

由图中可知，Base类的内存大小为12字节，首先存放的是虚表指针vfptr（占有4个字节），指向虚函数表vftable的首地址；接着按声明顺序依次存放类的变量m_A、m_B（各占有4个字节）。其中，虚函数表vftable按声明顺序依次存放类中定义的3个虚函数fun1、fun2、fun3的地址。我们发现，Base类的内存布局中并没有函数fun4，这是因为fun4是一个普通的成员函数，在类定义的时候就会存储在代码区，所以不在Base类的内存布局中。
注意：在设置“项目—>属性—>C/C++命令行—>其他选项”时，若要查看项目中所有类的内存布局，就写上"/d1 reportAllClassLayout"；若查看类XXX的内存布局时，就写上"/d1 reportSingleClassLayoutXXX"。

二、单一继承时，含虚函数类的内存布局剖析

定义一个Child类继承Base类，类的定义如下：

class Child :public Base
{
public:
	virtual void fun1() {};
	virtual void fun5() {};

private:
	int m_C;
};

选择“项目—>属性—>C/C++命令行—>其他选项”，修改为/d1 reportSingleClassLayoutChild，生成解决方案，输出行就会显示Child类的内存布局，如下图所示：

由图中可知，Child类的内存大小为16个字节，首先存放的是基类（Base类）的内存布局，依次为继承的虚表指针vfptr、变量m_A、变量m_B（均为4个字节）；接着存放的是派生类（Child类）的内存布局，即m_C，如有多个变量，则按照声明顺序依次存放。最后，我们可看到虚表指针vfptr指向的虚函数表已变为Child类作用域下，&Child::fun1为类Child中重写函数fun1的地址，覆盖了原来的&Base::fun1， &Base::fun2 、 &Base::fun3依旧为基类中函数fun2、fun3的地址不变，&Child::fun5为类Child新定义的函数fun5的地址。

三、利用虚函数实现多态

分析了含虚函数的基类和派生类的内存布局之后，接着一起看看如何利用虚函数实现多态。依旧用上述的类Child继承类Base，并给虚函数fun1体中写入不同的内容，代码如下：

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void fun1() { cout << "我是父亲" << endl; };
	virtual void fun2() {};
	virtual void fun3() {};
	void fun4() {};

protected:
	int m_A;
	int m_B;
};

class Child :public Base
{
public:
	virtual void fun1() { cout << "我是儿子" << endl; };
	virtual void fun5() {};
private:
	int m_C;
};

int main()
{
	Base* b;
	b = new Base;  //b指向一个Base对象
	b->fun1();

	b = new Child;  //b指向一个Child对象
	b->fun1();

	system("pause");
	return 0;
}

输出结果为：

从图中可以看到，当基类指针b指向基类（Base类）对象时，就会执行基类中的fun1函数体，当基类指针指向派生类（Child类）对象时，就会执行派生类中的fun1函数体，就形成了多态。同时，在代码测试中发现，基类指针b只能访问Child类中同基类共有的虚函数(fun1)，而无法访问Child类中的其它成员函数（fun5）以及成员变量（m_C）。

接着，一起分析一下案例中多态是如何实现的？基类指针b指向基类Base对象时，由Base类的内存布局可知，Base对象中有一个指向虚函数表的指针vfptr，当执行b->fun1()时，vfptr会指向虚表中fun1的地址（即&Base::fun1()）,就会执行Base::fun1()，输出结果“我是父亲”。由Child类的内存布局可知，Child类中同样有一个指向本类中虚函数表的指针vfptr。基类指针指向派生类Child对象时，对象类型会被转换为Base类，但对象类型转换并不会改变当前对象中vfptr指向的虚表，当再次执行b->fun1()时，此时vfptr指向虚表中fun1的地址仍为&Child::fun1() ,输出结果为“我的儿子”。由此可见，多态的实现是采用迟绑定的，即编译器在编译的时候发现fun1是虚函数，就不会确定调用的函数版本，而是在实际运行时根据对象的类型来调用对应的fun1函数体。

虚函数实现多态原理：当派生类继承基类时，在基类中利用virtual关键字定义若干个虚函数，会生成基类的虚表A，表中存放着所有虚函数的地址，而在派生类中重写某个虚函数func1时，派生类的的虚表B中，会用重写的虚函数地址覆盖原来的函数func1的地址，其它虚函数地址不变。程序采用迟绑定的编译模式，当基类指针指向基类对象时，基类对象的vptr指向虚表A，就会运行基类的func1；而基类指针指向派生类对象时，派生类对象的vptr指向虚表B，就会运行派生类的func1。这样，根据基类指针指向不同的对象，进而调用不同的函数体，就会有不同的表现形式，即实现多态。
多态实现的详细原理可参阅：https://blog.csdn.net/fightHHA/article/details/81626383。

四、利用纯虚函数实现多态

（1）纯虚函数是在基类中只声明不定义的虚函数，提供多态实现的接口，其声明方式为“virtual void function()=0”。
（2）含有纯虚函数的基类是纯虚基类，不能生成对象。
（3）派生类中必须对基类中声明的纯虚函数进行定义，否则无法编译。

纯虚函数使用情况：
在很多情况下，基类本身生成对象是不合情理的，这时就要在基类中声明一个纯虚函数，将基类变为一个抽象类，就无法生成基类对象。 例如，动物作为一个基类可以派生出小狗、小猫等派生类，但动物本身生成对象明显不合常理，因此将动物类定义为一个抽象类，就无法生成动物类对象。代码如下：

#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void fun() = 0;  //纯虚函数
};

class dog:public Animal
{
public:
	virtual void fun() { cout << "我是小狗" << endl; }
};

class cat :public Animal
{
public:
	virtual void fun() { cout << "我是小狗" << endl; }
};

int main()
{
	Animal* animal;
	//animal = new Animal;  //提示：不允许使用抽象类类型"Animal"的对象

	animal = new dog;
	animal->fun();

	animal = new cat;
	animal->fun();

	system("pause");
	return 0;
}

输出结果如下：

由代码和图可知，纯虚函数和虚函数的作用一样都是为了实现多态，区别就是无法生成抽象基类本身的对象。

1、C++中如何实现多态

• 基类中先声明一个虚函数
• 至少有一个继承该基类的子类

2、虚函数实现多态的原理

• 当一个类中出现虚函数或着子类继承了虚函数时，就会在该类中产生一个虚函数表（virtual table），虚函数表实际上是一个函数指针数组（在有的编译器作用下是链表），里面的每一个元素对应指向该类中的某一个虚函数的指针。被该类声明的对象会包含一个虚函数表指针（virtual table pointer），指向该类的虚函数表的地址。
• 虚函数的调用过程： 当一个对象要调用到虚函数时，先将对象内存中的vptr指针（虚函数表指针）指向定义该类的vtbl（虚函数表），vtbl再寻找里面的指针指向想要调用的虚函数，从而完成虚函数的调用。
  

2.1 单类继承

• 定义一个父类

class Person{
public:
	virtual void f(){cout << "use f()" << endl;}
	virtual void g(){cout << "use g()" << endl;}
	virtual void h(){cout << "use h()" << endl;}
};

父类对象其在内存中布局如下：

• 再定义一个子类，此时并不覆盖父类的虚函数：

class Bag:public Person{
public:
	virtual void i(){cout << "use i()" << endl;}
	virtual void j(){cout << "use j()" << endl;}
};

可以看出虚函数表内的虚函数是按声明顺序进行排序的
父类虚函数排在子类虚函数之前

• 当我们把子类中的虚函数覆盖掉：（修改Bag类）

class Bag:public Person{
public:
	void f(){cout << "class Bag use fun" << endl;}
	virtual void i(){cout << "use i()" << endl;}
	virtual void j(){cout << "use j()" << endl;}
}; 

子类覆盖的虚函数，放在父类原先放该虚函数的位置上。所以当父类指针指向该子类对象时，会调用该子类的重载函数

2.2 多类继承

• 子类没有覆盖父类的虚函数
  
  子类的虚函数放在第一张虚函数表中，紧跟着第一个父类的虚函数
  如果每个父类都有虚函数，则有几个父类就有几张虚函数表

• 子类覆盖父类的虚函数
  
  父类的虚函数被子类覆盖后，则该子类对应的重载函数的位置在被覆盖的父类函数的位置上。（如果父类没有该虚函数，则不用被覆盖）
  父类的虚函数被子类覆盖后，则父类指针指向该子类对象时，调用的f（）便是子类中重载的f（）

示例：

#include <iostream>
using namespace std;

class Person1{
public:
    virtual void f(){}
    virtual void g(){}
    virtual void h(){}
    virtual ~Person1(){}
};

class Person2{
public:
    virtual void f(){}
    virtual void g(){}
    virtual void h(){}
    void a(){           // 成员函数，不需要重载
        cout << "class Person2" << endl;
    }
    virtual ~Person2(){}
};

class Person3{
public:
    virtual void g(){}
    virtual void h(){}
    virtual ~Person3(){}
};

class Bag:public Person1, public Person2, public Person3{
public:
    void f(){
        cout << "Bag f()" << endl;
    }
    void g(){
        cout << "Bag g()" << endl;
    }
    void a(){
        cout << "Class Bag" << endl;
    }
};

int main(int argc, char const *argv[])
{
    Person3* p3 = new Bag;
    //p3->f();    // P3 没有成员函数f（）
                  // 多态首先得是 父类有虚函数，其次是子类要定义该函数的重载
                  // 如果父类的虚函数改为成员函数，则子类无法进行重载，即无法实现多态
    delete p3;
    p3 = NULL;

    Person1* p1 = new Bag;
    p1->f();
    delete p1;
    p1 = NULL;

    Person2* p2 = new Bag;
    p2->a();
    delete p2;
    p2 = NULL;
    
    return 0;
}

// virtualClass.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;
class Base
{
public:
	virtual void f(){ cout << "Base::f()" << endl; };
	void g(){ cout << "Base::g()" << endl; };
	void h(){ cout << "Base::h()" << endl; };
};

class Derive:public Base
{
public:
	virtual void f(){ cout << "Derive::f()" << endl; };
	void g1(){ cout << "Derive::g1()" << endl; };
	void h1(){ cout << "Derive::h1()" << endl; };
};

int _tmain(int argc, _TCHAR* argv[])
{
	Base *p = new Derive();
	Base *p1 = new Base();
	p->f();
	p1->f();
	return 0;
}

内部的实现原理可参考：虚函数实现原理
c++语言虚函数实现多态的原理（更新版）

• 虚函数表的原理

#include <iostream>
using namespace std;

//父类
class Base
{
public:
	virtual void f() { cout << "Base::f()" << endl; }
	virtual void g() { cout << "Base::g()" << endl; }
	virtual void h() { cout << "Base::h()" << endl; }
};
class Derive :public Base
{
	virtual void g() { cout << "Derive::g()" << endl; }
};

int main()
{
	//继承关系作用下虚函数的手工调用			
	cout << sizeof(Base) << endl;
	cout << sizeof(Derive) << endl;

	Derive *d = new Derive(); //派生类指针。
	long *pvptr = (long *)d;  //指向对象的指针d转成了long *类型。
	long *vptr = (long *)(*pvptr); //(*pvptr) 表示pvptr指向的对象，也就是Derive本身。Derive对象是4字节的，代表的是虚函数表指针地址。

	for (int i = 0; i <= 4; i++) //循环5次；
	{
		printf("vptr[%d] = 0x:%p\n", i, vptr[i]);
	}

	typedef void(*Func)(void); //定义一个函数指针类型
	Func f = (Func)vptr[0]; //f就是函数指针变量。 vptr[0]是指向第一个虚函数的。
	Func g = (Func)vptr[1];
	Func h = (Func)vptr[2];

	f();
	g();
	h();
	//i();

	Base *dpar = new Base();
	long *pvptrpar = (long *)dpar;
	long *vptrpar = (long *)(*pvptrpar);

	for (int i = 0; i <= 4; i++) //循环5次；
	{
		printf("vptr Base[%d] = 0x:%p\n", i, vptrpar[i]);
	}

	Func fpar = (Func)vptrpar[0];
	Func gpar = (Func)vptrpar[1];
	Func hpar = (Func)vptrpar[2];

	cout << "--------------------" << endl;
	fpar();
	gpar();
	hpar();

	return 1;
}