C++中虚函数的原理和虚函数表

一， 什么是虚函数

简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略，虚函数是C++的多态性的主要体现，指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

下面我们从这段代码中来进行分析：

 

---

#include<iostream> using namespace std; class A{ public: A(); void fun1(); void fun2(); }; A::A() { } void A::fun1() { cout<<"I am in class A fun1"<<endl; } void A::fun2() { cout<<"I am in class A fun2"<<endl; } class B:public A { public: B(); void fun1(); //默认的从父类继承来，就是虚函数 void fun2(); }; void B::fun1() { cout<<"I am in class B fun1"<<endl; } void B::fun2() { cout<<"I am in class B fun2"<<endl; } B::B() { } void main() { A a; B b; cout<<"a.fun1() : "<<endl; a.fun1(); cout<<"a.fun2() : "<<endl; a.fun2(); cout<<"b.fun1() : "<<endl; b.fun1(); cout<<"b.fun2() : "<<endl; b.fun2(); }

运行结果很简单

I am in class A fun1

I am in class A fun2

I am in class B fun1

I am in class B fun2

但这是否真正做到了多态性呢？No，多态还有个关键之处就是一切用指向基类的指针或引用来操作对象。那现在就把main()处的代码改一改。

#include<iostream> using namespace std; class A{ public: A(); void fun1(); void fun2(); }; A::A() { } void A::fun1() { cout<<"I am in class A fun1"<<endl; } void A::fun2() { cout<<"I am in class A fun2"<<endl; } class B:public A { public: B(); void fun1(); void fun2(); }; void B::fun1() { cout<<"I am in class B fun1"<<endl; } void B::fun2() { cout<<"I am in class B fun2"<<endl; } B::B() { } void main() { A a; B b; A *ptr; ptr=&a; cout<<"ptr=&a; prt->fun1(): "<<endl; ptr->fun1(); cout<<"ptr=&a; prt->fun2(): "<<endl; ptr->fun2(); ptr=&b; cout<<"ptr=&b; prt->fun1(): "<<endl; ptr->fun1(); cout<<"ptr=&b; prt->fun2(): "<<endl; ptr->fun2(); }

这次的运行结果

I am in class A fun1

I am in class A fun2

I am in class A fun1

I am in class A fun2

问题来了，ptr明明指向的B的对象，为什么调用的却是A的函数呢？要解决这个问题，就要用到了虚函数，我们在修改函数

#include<iostream> using namespace std; class A{ public: A(); virtual void fun1(); void fun2(); }; A::A() { } void A::fun1() { cout<<"I am in class A fun1"<<endl; } void A::fun2() { cout<<"I am in class A fun2"<<endl; } class B:public A { public: B(); virtual void fun1(); //默认的从父类继承来，就是虚函数 void fun2(); }; void B::fun1() { cout<<"I am in class B fun1"<<endl; } void B::fun2() { cout<<"I am in class B fun2"<<endl; } B::B() { } void main() { A a; B b; A *ptr; ptr=&a; cout<<"ptr=&a; prt->fun1(): "<<endl; ptr->fun1(); cout<<"ptr=&a; prt->fun2(): "<<endl; ptr->fun2(); ptr=&b; cout<<"ptr=&b; prt->fun1(): "<<endl; ptr->fun1(); cout<<"ptr=&b; prt->fun2(): "<<endl; ptr->fun2();

这时候我们发现运行结果变了

I am in class A fun1

I am in class A fun2

I am in class B fun1

I am in class A fun2

因为fun1是虚函数，B类继承A类的fun1默认也是虚函数，简单总结下，指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

fun2不是虚函数，所以调用的仍旧是A类的fun2函数

二， 虚函数是如何做到的

虚函数是如何做到因对象的不同而调用其相应的函数的呢？现在我们就来剖析虚函数

class A{ 　　public: 　　virtual void fun(){cout<<1<<endl;} 　　 virtual void fun2(){cout<<2<<endl;} 　　 }; 　　 class B:public A{ 　　public: 　　void fun(){cout<<3<<endl;} 　　void fun2(){cout<<4<<endl;} 　　 };

由于这两个类中有虚函数存在，所以编译器就会为他们两个分别插入一段你不知道的数据，并为他们分别创建一个表。那段数据叫做vptr指针，指向那个表。那个表叫做vtbl，每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址，请看图

可以看到这两个vtbl分别为class A和class B服务。现在有了这个模型之后，我们来分析下面的代码

A *p=new A;

　　p->fun();

毫无疑问，调用了A::fun()，但是A::fun()是如何被调用的呢？它像普通函数那样直接跳转到函数的代码处吗？No，其实是这样的，首先是取出vptr的值，这个值就是vtbl的地址，再根据这个值来到vtbl这里，由于调用的函数A::fun()是第一个虚函数，所以取出vtbl第一个slot里的值，这个值就是A::fun()的地址了，最后调用这个函数。现在我们可以看出来了，只要vptr不同，指向的vtbl就不同，而不同的vtbl里装着对应类的虚函数地址，所以这样虚函数就可以完成它的任务。

---

而对于class A和class B来说，他们的vptr指针存放在何处呢？其实这个指针就放在他们各自的实例对象里。由于class A和class B都没有数据成员，所以他们的实例对象里就只有一个vptr指针。通过上面的分析，现在我们来实作一段代码，来描述这个带有虚函数的类的简单模型

#include<iostream> 　　 using namespace std; 　　 //将上面“虚函数示例代码”添加在这里 　　 int main(){ 　　void (*fun)(A*); 　　A *p=new B; 　　long lVptrAddr; 　　memcpy(&lVptrAddr,p,4); 　　memcpy(&fun,reinterpret_cast<long*>(lVptrAddr),4); 　　 fun(p); 　　delete p; 　　system("pause"); 　　 }

用VC或Dev-C++编译运行一下，看看结果是不是输出3，void (*fun)(A*); 这段定义了一个函数指针名字叫做fun，而且有一个A*类型的参数，这个函数指针待会儿用来保存从vtbl里取出的函数地址

A* p=new B; new B是向内存(内存分5个区:全局名字空间,自由存储区,寄存器,代码空间,栈)自由存储区申请一个内存单元的地址然后隐式地保存在一个指针中.然后把这个地址附值给A类型的指针P.

long lVptrAddr; 这个long类型的变量待会儿用来保存vptr的值

memcpy(&lVptrAddr,p,4); 前面说了，他们的实例对象里只有vptr指针，所以我们就放心大胆地把p所指的4bytes内存里的东西复制到lVptrAddr中，所以复制出来的4bytes内容就是vptr的值，即vtbl的地址

现在有了vtbl的地址了，那么我们现在就取出vtbl第一个slot里的内容

memcpy(&fun,reinterpret_cast<long*>(lVptrAddr),4); 取出vtbl第一个slot里的内容，并存放在函数指针fun里。需要注意的是lVptrAddr里面是vtbl的地址，但lVptrAddr不是指针，所以我们要把它先转变成指针类型

fun(p); 这里就调用了刚才取出的函数地址里的函数，也就是调用了B::fun()这个函数，也许你发现了为什么会有参数p,其实类成员函数调用时，会有个this指针，这个p就是那个this指针，只是在一般的调用中编译器自动帮你处理了而已，而在这里则需要自己处理。

delete p; 释放由p指向的自由空间;

如果调用B::fun2()怎么办？那就取出vtbl的第二个slot里的值就行了

memcpy(&fun,reinterpret_cast<long*>(lVptrAddr+4),4); 为什么是加4呢？因为一个指针的长度是4bytes，所以加4。或者memcpy(&fun,reinterpret_cast<long*>(lVptrAddr)+1,4); 这更符合数组的用法，因为lVptrAddr被转成了long*型别，所以+1就是往后移sizeof(long)的长度

 

---

虚函数表

 

类的虚函数表是一块连续的内存，每个内存单元中记录一个JMP指令的地址

　　注意的是，编译器会为每个有虚函数的类创建一个虚函数表，该虚函数表将被该类的所有对象共享。类的每个虚成员占据虚函数表中的一行。如果类中有N个虚函数，那么其虚函数表将有N*4字节的大小。

　　虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

　　编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着可以通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。