虚函数表指针，虚函数表详解

虚函数表

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

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。没关系，下面就是实际的例子，相信聪明的你一看就明白了。

假设我们有这样的一个类：

class Base {

public:

virtual void f() { cout << "Base::f" << endl; }

virtual void g() { cout << "Base::g" << endl; }

virtual void h() { cout << "Base::h" << endl; }

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。下面是实际例程：

typedef void(*Fun)(void);

Base b;

Fun pFun = NULL;

cout << "虚函数表地址：" << (int*)(&b) << endl;

cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;

// Invoke the first virtual function

pFun = (Fun)*((int*)*(int*)(&b));

pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0); // Base::f()

(Fun)*((int*)*(int*)(&b)+1); // Base::g()

(Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

一般继承（无虚函数覆盖）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。

一般继承（有虚函数覆盖）

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序，

Base *b = new Derive();

b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

多重继承（无虚函数覆盖）

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

1）每个父类都有自己的虚表。

2）子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多重继承（有虚函数覆盖）

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

以上内容来自：http://hi.baidu.com/smart_bee/blog/item/163e2c23e54d23ac4623e85d.html

1:虚表(虚函数表)是for类的
2:基类和派生类是各有各的表,也就是说他们的物理地址是分开的,基类和派生类的虚表的唯一关联是:当派生类没有实现基类虚函数的重载时,派生类会直接把自己表的该函数地址值写为基类的该函数地址值.
3:任何一个有虚表的类,在实例化时不允许其虚表内有项为空->纯虚类不能初始化对象
4:带虚表的类在对象构造函数中,会把一个指针指向该类虚表地址,我在这给它起个名字叫vp;
5:仅对于VC和BC两种编译器论,如果该类带有虚表,那么该类的对象的首地址就是虚表地址,也是this指针指向虚表

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

Derive d;

Base1 *b1 = &d;

Base2 *b2 = &d;

Base3 *b3 = &d;

b1->f(); //Derive::f()

b2->f(); //Derive::f()

b3->f(); //Derive::f()

b1->g(); //Base1::g()

b2->g(); //Base2::g()

b3->g(); //Base3::g()

安全性

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

一、通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

Base1 *b1 = new Derive();

b1->f1(); //编译出错

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，（但可以通过将b1强制转换成Derive*之后可以访问Derive类中的所有成员函数）所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

二、访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

如：

class Base {

private:

virtual void f() { cout << "Base::f" << endl; }

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {

Derive d;

Fun pFun = (Fun)*((int*)*(int*)(&d)+0);

pFun();

}

以下内容来自：http://blog.163.com/anklean/blog/static/176296062008035734675/

在进入主题之前先介绍一下联编的概念。联编就是将模块或者函数合并在一起生成可执行代码的处理过程，同时对每个模块或者函数调用分配内存地址，并且对外部访问也分配正确的内存地址。按照联编所进行的阶段不同，可分为两种不同的联编方法：静态联编和动态联编。在编译阶段就将函数实现和函数调用关联起来称之为静态联编，静态联编在编译阶段就必须了解所有的函数或模块执行所需要检测的信息，它对函数的选择是基于指向对象的指针（或者引用）的类型。反之在程序执行的时候才进行这种关联称之为动态联编，动态联编对成员函数的选择不是基于指针或者引用，而是基于对象类型，不同的对象类型将做出不同的编译结果。C语言中，所有的联编都是静态联编。C++中一般情况下联编也是静态联编，但是一旦涉及到多态性和虚函数就必须使用动态联编。
多态性是面向对象的核心，它的最主要的思想就是可以采用多种形式的能力，通过一个用户名字或者用户接口完成不同的实现。通常多态性被简单的描述为"一个接口，多个实现。在C++里面具体的表现为通过基类指针访问派生类的函数和方法。
下面我们看一个静态联编的例子，这种静态联编导致了我们不希望的结果。

//1.cpp
1. #include <iostream.h>
2. class shape{
3.  public:
4.    void draw(){cout<<"I am shape"<<endl;}
5.    void fun(){draw();}
6. };
7. class circle:public shape{
8.  public:
9.    void draw(){cout<<"I am circle"<<endl;}
10. };
11. main(){
12.    class circle  oneshape;
13.    oneshape.fun();
14. }

程序的输出结果我们希望是"I am circle"，但事实上却输出了"I am shape"的结果，造成这个结果的原因是静态联编。静态联编需要在编译时候就确定函数的实现，但事实上编译器在仅仅知道shape的地址时候无法获取正确的调用函数，它所知道的仅是shape::draw()，最终结果只能是draw操作束缚到shape类上。产生"I am shape"的结果就不足为奇了。
为了能够引起动态联编，我们只需要将需要动态联编的函数声明为虚函数即可。动态联编只对虚函数起作用。我们在通过基类而且只有通过基类访问派生类的时候，只要这个基类中直接的或者间接（从上上层继承）的包含虚函数，动态联编将自动唤醒。下面我们将上面的程序稍微改一下。

//2.cpp
1. #include <iostream.h>
2. class shape{
3.  public:
4.    virtual void draw(){cout<<"I am shape"<<endl;}
5.    void fun(){draw();}
6. };
7. class circle:public shape{
8.  public:
9.    void draw(){cout<<"I am circle"<<endl;}
10. };
11. main(){
12.    class circle  oneshape;
13.    fun(&oneshape);
14. }

程序执行得到了正确的结果"I am circle"。代码在VC6.0中执行。

到目前为止我们不清楚动态联编的执行机制，但我们可以做个猜测。正如上面所说，对于函数的实际的对象类型不同，联编结果也应该不同。在静态联编中，执行的困难在于无法通过基类知道需要联编的子对象的确切类型。在1.cpp中shape的派生类既可能是circle,也可能是其余的rectangle或者square等等，到底应该静态联编哪一个呢。迷惑正在于此。动态联编在编译的时候应该也是不知道联编的确切对象类型的，（如果知道的话就成了静态联编了），因此它只能通过一定的机制，使得在执行时候能够找到和调用正确的函数体。可以想象，为了达到这个目的，一些相关信息应该封装在对象自身中。这些信息有点象身份证明，标识自己，这样在动态联编的时候，编译器可以根据这些标记找到相应的函数体，"不要跑，就是你了"。
实际上的动态联编过程是什么样的呢。

二对象类型信息

为了证明我们的猜想，我们用下面的一个程序进行测试，下面的程序将获取普通的类和包含虚函数的类的字节大小。程序代码如下。

//3.cpp
1. #include <iostream.h>
2. class shape_novirtual{
3.      int   a;
4.   public:
5.      void  draw(){cout<<"shape_novirtual::draw()"<<endl;}
6. };
7. class shape_virtual1{
8.      int   a;
9.   public:
10.      virtual void draw(){cout<<"shape_virtual::draw()"<<endl;}
11. };
12. class shape_virtual2{
13.      int  a;
14.   public:
15.      virtual void draw(){cout<<"shape_virtual2::draw()"<<endl;}
16.      virtual void draw1(){cout<<"shape_virtual2::draw1()"<<endl;}
17. };
18. main(){
19.   cout<<"sizeof(int)"<<sizeof(int)<<endl;
20.   cout<<"sizeof(class shape_novirtual):"<<sizeof(shape_novirtual)<<endl;
21.   cout<<"sizeof(void*):"<<sizeof(void*)<<endl;
22.   cout<<"sizeof(class shape_virtual):"<<sizeof(shape_virtual)<<endl;
23.   cout<<"sizeof(class shape_virtual2):"<<sizeof(shape_virtual2)<<endl;
24. }

VC6.0中运行结果如下：

sizeof(int)4
sizeof(class shape_novirtual):4
sizeof(void*):4
sizeof(class shape_virtual1):8
sizeof(class shape_virtual2):8
Press any key to continue

从上面可以看出，没有虚函数的类shape_novirtual的大小为4，正好为int a的大小。而带有虚函数的类shape_virtual1和shape_virtual2的大小除了int a的大小还多出了4格个字节的大小，这个大小正好是void*指针的大小。到现在为止我们基本上可以说带有虚函数的对象自身确实插入了一些指针信息，而且这个指针信息并不随着虚函数的增加而增大。
如果我们将每个类的成员变量int a去掉，VC6.0运行结果就会变成下面的情况。

sizeof(int)4
sizeof(class shape_novirtual):1
sizeof(void*):4
sizeof(class shape_virtual1):4
sizeof(class shape_virtual2):4
Press any key to continue

上面的运行结果应该让人感到例外。既然size(int)为4，现在没有了这个成员变量，类shape_novirtual应该字节大小为0，但事实上C++编译器不允许对象为零长度。试想一个长度为0的对象在内存中怎么存放？怎么获取它的地址？为了避免这种情况，C++强制给这种类插入一个缺省成员，长度为1。如果有自定义的变量，变量将取代这个缺省成员。

三虚函数表VTABLE

动态联编过程跟我们猜测的大致相同。编译器在执行过程中遇到virtual关键字的时候，将自动安装动态联编需要的机制，首先为这些包含virtual函数的类（注意不是类的实例）--即使是祖先类包含虚函数而本身没有--建立一张虚拟函数表VTABLE。在这些虚拟函数表中，编译器将依次按照函数声明次序放置类的特定虚函数的地址。同时在每个带有虚函数的类中放置一个称之为vpointer的指针，简称vptr，这个指针指向这个类的VTABLE。

关于虚拟函数表，有几点必须声明清楚：

1. 每一个类别只能有一个虚拟函数表，如果该类没有虚拟函数，则不存在虚拟函数表。

2. C++编译时候编译器会在含有虚函数的类中加上一个指向虚拟函数表的指针vptr。

3. 从一个类别诞生的每一个对象，将获取该类别中的vptr指针，这个指针同样指向类的VTABLE。

因此类、对象、VTABLE的层次结构可以用下图表示。其中X类和Y类的对象的指针都指向了X,Y的虚拟函数表，同时X,Y类自身也包含了指向虚拟函数的指针。

为了方便问题说明，我们将2.cpp例子进行扩展，扩展程序如下。

#include <iostream.h >
16. class shape{
17. public:
18. virtual void draw(){cout<<"shape::draw()"<<endl;}
19. virtual void area(){cout<<"shape::area()"<<endl;}
20. void fun(){draw();area();}
21. };
22. class circle:public shape{
23. public:
24. void draw(){cout<<"circle::draw()"<<endl;}
25. void adjust(){cout<<"circle::adjust()"<<endl;}
26. };
27. main(){
28. shape oneshape;
29. oneshape.fun();
30.
31. circle circleshape;
32. shape& baseshape=circleshape;
33. baseshape.fun();
34. }

编译器在编译上面这段代码的时候将为这shape和circle两个对象分别建立一个VTABLE表，这些表依次填充派生类对象和基类对象中声明的所有的虚函数地址。如果派生类本身没有重新定义基类的虚函数，那么填充的就是基类的虚函数地址。这样一旦如果函数调用一个派生类不存在的方法时候能够自动调用基类方法。然后编译器在每个类中放置一个vptr，一般置于对象的起始位置，继而在对象的构造函数中将vptr初始化为本类的VTABLE的地址。整个结果布局如下。

这张图有点问题

图一

图一中的rectangle的VTABLE中的area() 和triangle的VTABLE的adjust()都是填充的基类的虚函数地址。 C++ 编译程序时候按下面的步骤进行工作:

①为各类建立虚拟函数表，如果没有虚函数则不建立。

②暂时不连接虚函数，而是将各个虚函数的地址放入虚拟函数表中。

③直接连接各静态函数。

这些工作做完之后，模块图如图二：

执行时候，诞生了oneshape和circleshape两个对象，oneshape对象的vptr指针指向shape的VTABLE，circleshape对象的vptr指针指向circleshape的VTABLE，在执行oneshape.fun()的时候，fun函数的this指针指向了oneshape对象，进入fun()之后程序继续执行this->draw()，由于this指向oneshape对象，oneshape的vptr又指向shape类的VTABLE，这样就从VTABLE中得到需要绑定的函数的地址，并连接起来。同样，this-> area()也经由oneshape对象而连接到相应的函数上，如图三。

图三

现在我们执行baseshape.fun()函数。

circle circleshape;shape& baseshape=circleshape;baseshape.fun();函数进入fun函数之后，函数的this指针将指向basefun对象，另一方面basefun指向一个circleshape，因此this指针指向的实际上为circleshape对象，而circleshape的vptr指针指向circle类的虚拟函数表，这样编译器将从虚拟表中取出circle::draw()和circle::area()的地址，进行连接。因为circle本身没有重新定义area()方法，因此编译器使用shape的area()方法。如图四。

图四

遵循上面的思路，基于基类的指针总能找到正确的子类对象的实现。但是象上面的 this->draw是怎么编译的呢。

四编译内幕

在上面的程序中，this指针不同，从而连接到不同的fun函数。那么C++如何编译这些指令呢。道理在于：所有的基类的派生类的虚拟函数表的顺序与基类的顺序是一样的，对于基类中不存在方法再按照声明次序进行排放。这样不管是shape还是circle或者从shape又继承出来的其余的类它们的虚拟函数表的第一项总是draw函数的地址，然后是area的地址。对于circle类，下面的才是adjust的地址。因此不管对于shape还是circle，this->draw总是编译成 call this->VTABLE[0]; this->area()总是翻译成 call this->VTABLE[1]; 程序到真正运行时候将会发现this的真正指向的对象，如果是shape,则调用shape->VTABLE[0]，如果是circle，则调用circle->VTABLE[1]。

http://hi.baidu.com/j_u_s_t_l_o_v_e/blog/item/3599b889a273c999a5c27253.html

posted on 2012-06-25 21:08 h2内存数据库阅读(1336) 评论(0) 编辑收藏举报

刷新页面返回顶部

h2内存数据库