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

晨曦之光 发布于 2012/04/13 11:19
阅读 519
收藏 0

一, 什么是虚函数

简单地说,那些被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。在这个表中,主要是一个类的虚函数的地址表,这张表解决了继承、覆盖的问题,保证其真实反应实际的函数。这样,在有虚函数的类的实例中这个表被分配在了这个实例的内存中,所以,当用父类的指针来操作一个子类的时候,这张虚函数表就显得由为重要了,它就像一个地图一样,指明了实际所应该调用的函数。

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

 


原文链接:http://blog.csdn.net/xie376450483/article/details/5964345
加载中
返回顶部
顶部