前言：如果对多态不太了解的话，可以看我的这篇文章《C++多态》，另外本文中出现到的汇编代码，我都会予以解释，看不懂没关系，知道大概意思就行，能不讲汇编的地方我就不讲；

           本文使用到的工具是vs2010；

目录

虚表是什么？ 

        实现多态的关键-virtual关键字底层

        虚表占用字节数

        总结

虚表的结构

虚表的内容

        虚表中函数的调用

总结

结语

---

虚表是什么？ 

        虚表也被称为虚函数表，我们知道，实现多态的主要因素还是virtual这个关键字，加上这个关键字的函数被称为虚函数，C++中的虚函数的实现一般是通过虚函数表(C++规范并没有规定具体用哪种方法，但大部分的编译器厂商都选择此方法)；

        为了引出所谓的虚表，我们要先从virtual关键字下手；

        实现多态的关键-virtual关键字底层

        我们知道实现多态的关键是virtual关键字，那么带不带virtual关键字在底层有什么区别呢？测试代码test01，如下：

#include <stdio.h>
#include <Windows.h>>

class Person
{
public:
	int x;
	void print()
	{
		printf("父类输出。\n");
	}
};

class Teacher:public Person
{
public:
	void print()
	{
		printf("子类输出。\n");
	}
};

void Func(Person* p)
{
	p->print();                        // 此处下断点
}

int main()
{
	Person p;
	Teacher t;

    Func(&t);           // 因为父类指针可以指向子类对象，所以这里没问题

	return 0;
}

        首先，创建一个父类，父类中有成员x和函数print；子类Teacher继承Person；重写print函数，然后在主函数中，我们定义一个父类对象一个子类对象就行了；

        我们知道不使用virtual关键字的时候，是不能实现多态的，所以这里我们在p->print()这个可能实现多态的位置下一个断点，观察其反汇编：

        f7编译，f5运行，alt+8转到反汇编：

        我们给父类函数加上virtual关键字：

        再次查看汇编代码：

        我们大致可以总结一下带virtual关键字和不带virtual关键字的时候有什么区别？也就是说virtual是如何实现多态的：

        不带virtual的时候，底层是直接调用，已经指定了Person的print函数，无法实现多态；

        带virtual的时候，底层是间接调用，只是给出了一个地址，可以是Person的print也可以是Teacher的，可以实现多态；

        知道了virtual关键字实现多态的关键了，下面我们来分析一段virtual底层的汇编代码：

        就分析这一段吧；

        首先我们来看第一段汇编指令：mov eax,dword ptr [p]；

        他的意思就是将p这个地址中的内容存放到eax寄存器里；

        那么p是什么呢？p就是我们传给print()函数的参数，这里我们传入的是子类的对象t，那么p就是 Person* p = &t;是一个指向子类对象首地址的指针，那么上面这一行汇编的意思就是将子类对象t的首地址存放到eax中，那么此时的eax中存放的是&t；

        然后看第二段汇编：mov edx,dword ptr [eax]；

        没错，他的意思是将eax中&t这个地址中的值取出存放到edx中；

        那么&t这个地址中的值是什么呢？因为&t是对象t的首地址，所以&t中的值就是t的第一个成员啊，看到这里你可能会觉得t的第一个成员不就是继承过来的x嘛，其实不是的，我们继续看；

        已知我们现在将t的第一个成员存放到edx中了；

        然后看第三段汇编：mov esi,esp；

        这个汇编没必要看，只是备份一下esp的值，等会用来比较堆栈是否平衡；

        然后看第四段汇编：mov ecx,dword ptr[p]；

        这段汇编应该能看懂了吧，将p中对象t的首地址放在ecx中；

        然后看第五段汇编：mov eax,dword ptr [edx]；

        重点来了重点来了重点来了！！！

        让我们回忆一下，此时edx中存放的是t的第一个成员，我们取第一个成员地址中的值放到eax中，如果第一个成员是x的话，我们取x这个地址中的值，这是违法的不被允许的；为什么？x它是一个int类型的变量，他不是一个地址，x的值是我们赋给他的值，如果我们给x赋值1，那么&0x1这个地址中的值，操作系统是不允许的，因为我们没有权限；

        所以t的第一个成员肯定不是变量x！！！记住这个结论。

        我们明明只定义了一个x啊，如果不是x还能是什么？难道说......另有其人？那它是什么呢？

        下面为大家揭秘：

        虚表占用字节数

        想要知道t的第一个成员是什么，我们首先要知道t他到底有几个成员；我们用最简单的测试：sizeof()函数；

        首先我们还是先去掉virtual关键字

        然后sizeof一下Person和Teacher的对象看一下大小：

        都是四个字节，也就是成员x；

        那么我们加上virtual关键字看一下大小：

         竟然变成了8个字节！！！！

        我们现在大概可以确定，加上virtual关键之后，类中另有成员！！！不止变量x； 

        不急，我们先看一下，如果我们定义两个成员的话，大小是多少呢？

        运行输出：

        全变成12字节了；

        我们现在大致可以确定虚函数virtual在类中有一个大小为4字节的虚表 

        那么是不是说，一个virtual虚函数的虚表就占用4个字节？两个占用两个？

        测试一下，再加一个虚函数：

        运行输出：

        还是12；

        其实从定义我们就可以知道，虚表之所以叫表，肯定不止是存放一个地址啊，肯定可以存放很多，但是为什么一整张表能够做到只占用四个字节？因为我们传入的当然不可能是一整张表，而是表的首地址，是一个名叫__vfptr的指针，我们下面会说；

        到现在我们大致可以总结一下了；

        总结

        我们可以确认了，如果类中具有virtual修饰的虚函数，无论有多少个虚函数，类的对象在底层中只有一个虚表，因为我们传入的是虚表的首地址，只占用四个字节，并且这个虚表首地址是类对象的第一个成员！

虚表的结构

        知道虚表的位置了之后，我们就要研究虚表的结构了，究竟是一个什么样的四字节？可以存放那么多函数的地址；

        已知此时我们的父类拥有两个虚函数，两个对象，子类重写了两个虚函数；

        我们在main函数中就定义两个对象，然后调用Func函数，然后在return 0;的地方下断点：

        考虑到大家可能不了解汇编，所以这里我按照编译器给出的结果去给大家讲，能不用汇编就不用汇编了；

        我们f5调试一下：

        随便找一个监视窗口：

        然后我们在窗口中输入对象p和对象t，代表监视这两个对象：

        我们点开对象旁边的"+"，可以看到对象中依次排列的成员：

 

        我们可以看到，p的第一个成员是一个叫做__vfptr的东西，他是一个指针，指向我们虚函数表的首地址，他指向的地址里面存放的就是我们所说的虚函数表；先看父类，__vfptr其实就是一个地址，占四个字节；

        继续往下，我们点开__vfptr旁边的+号：

        里边存放了两个函数？我们现在大胆猜一下，__vfptr这个指针（虚表的首地址）指向的地址存放了这两个虚函数的调用地址，是这样吗？我们把0x00c55740复制到内存窗口，看一下：

        是的，没错；__vfptr指针指向的地址中存放了其他虚函数的地址；

        我们大致可以总结一下虚表的结构了。

        为什么只占用四个字节的虚表，可以存放很多虚函数的地址？

        因为我们类的底层存放的并不是一整张表，而只是虚表的首地址，也就是一个名叫__vfptr的指针，这个指针指向的地址中存放了其他所有虚函数的调用地址；

虚表的内容

        我们现在只是模糊的知道了，虚表的内容是其他函数的调用地址，但是都是哪些函数呢？我们暂且还不知道；因为我们还没有测试，下面我们来进行测试；

        其他的代码不变，主函数中，传入&p；

         为了方便看p对象与t对象虚函数的成员，我们断点打在return 0；这里：

        点开旁边的"+"号：

 

        我们发现，对象p的虚函数表中存放着两个函数，一个Person::print()，一个是Person::print1()，对象t也一样，存放着两个函数，一个是Teacher::print()，一个是Teacher::print1()；

        那么，我们知道，这是我们子类重写的情况下，才是这样一个结果，父类的表中存放父类成员，子类的表中存放子类成员；

        但是，我们也知道，只要父类写了virtual虚函数，不管子类有没有重写，底层对函数的调用都是间接调用，不是直接调用；

        也就是说，无论子类有没有重写，在Func函数中p->print()这里的调用，子函数都必须传入一个__vfptr虚表，那么如果子类没有重写父类的虚函数时，虚表中存放的是什么呢？

        我们继续测试：

        现在我们将子类的重写全部删掉，如下：

        其他代码不变，断点依旧return 0;调试一下：

        我们看到，父类中还是存放了父类的虚函数成员，这个时候子类因为没有重写，也存放了父类的虚函数成员；

        我们现在可以大致总结一下虚表的内容了；

        如果父类有n个虚函数那么父类的虚表中就存放这n个虚函数的地址；子类的虚表中也是存放了n个函数的地址，如果子类中重写了父类的虚函数，那么子类虚表中就用子类自己重写后的函数地址，如果子类中有的函数没有重写父类的虚函数，那么虚表中的该调用地址就用父类的函数；

        虚表中的函数如何调用

        已知，我们现在已经很清楚的了解了虚表中的内容，就是存放了待调用函数的地址；那么调用函数的时候底层是怎么调用的呢？

        我们先调用p的print函数，print函数是p虚表的第一个成员，断点打在函数调用的地方：

        f5调试，alt+8转到反汇编：

 

        f11跟进，到call eax的内部，看它调用的是谁：

 

        是Person::print()；没错，调用print()时，我们传入的是edx（虚表的首地址）；

        我们把调用的函数换成print1()：

 

        其他不变，继续调试，转到反汇编：

 

        我们可以看到，这次调用的地址是edx+4；我们已知edx就是虚表的首地址，那么edx+4中存放是什么呢？

        f11跟进：

 

        可以看到edx+4存放的是print1();也就是第二个虚函数的调用地址；

        那么我们现在可以总结一下，虚表中的那么多的函数地址是怎么调用的呢？

        通过指针偏移调用！

        从编译结束的那一刻起__vfptr只是一个首地址，是一个指针，__vfptr+4就是第二个函数的地址，可想而知+8就是第三个虚函数的地址，当然前提是你有第三个虚函数；

总结

        1、虚表就是一个存放了很多函数调用地址的表，我们类的第一个成员是虚表的首地址，只占用四个字节；

        2、如果父类有n个虚函数那么父类的虚表中就存放这n个虚函数的地址；子类的虚表中也是存放了n个函数的地址，如果子类中重写了父类的虚函数，那么子类虚表中就用子类自己重写后的函数地址，如果子类中有的函数没有重写父类的虚函数，那么虚表中的该函数的调用地址就用父类的函数；

        3、虚函数的调用是通过指针偏移实现的，__vfptr本身就是一个指针，__vfptr+0中存放着第一个虚函数的调用地址，__vfptr+4中存放着第二个虚函数的调用地址，以此类推；

        4、含有虚函数的类的第一个成员是__vfptr，vfptr本身是一个指针，它指向的地址中存放了连续的四字节地址，也就是其他虚函数的调用地址，形成了一张表，称为虚表；我们类的底层的第一个成员是__vfptr指针，不是一整张表，这也就是为什么四字节的地址可以存放很多虚函数的原因；

结语

        本篇文章，个人感觉可能讲的比较绕，如果有哪个地方没有看懂，可以向我提出来，我们加以修改，尽量通俗易懂；如果有什么意见、建议或者错误都请提出来，谢谢大家！