虚函数及虚函数表

ゝ一纸荒年。 2021-09-25 00:18 416阅读 0赞

# **虚函数及虚函数表** #

**各个类对象共享类的虚函数表，每个类对象有个虚函数指针vptr****，虚函数指针vptr指向虚函数表（对于只有一个虚函数表的情况）。**

**虚函数**

**简单的说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类的所有虚函数对应的函数指针。**

**C++中的虚函数的作用主要是实现了多态的机制**。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

**虚函数表**

**虚函数（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()

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

![20201126113727153.jpeg][]

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

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

**简单地说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类所有的虚函数对应的函数指针****。**

## **单继承（无虚函数覆盖）** ##

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 \{

public:

virtual void f1() \{ cout << "Derive::f1()" << endl; \}

virtual void g1() \{ cout << "Derive::g1()" << endl; \}

virtual void h1() \{ cout << "Derive::h1()" << endl; \}

\};

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

![20201126113727299.jpeg][]

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

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

![20201126113727153.jpeg][]

**我们可以看到下面几点：**

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

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

## **单继承（有虚函数覆盖）** ##

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

![20201126113727293.jpeg][]

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 \{

public:

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

virtual void g1() \{ cout << "Derive::g1()" << endl; \}

virtual void h1() \{ cout << "Derive::h1()" << endl; \}

\};

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

![20201126113727335.jpeg][]

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

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

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

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

Base \*b = new Derive();

b->f();

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

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

**当一个类继承多个类，且多个基类都有虚函数时，子类对象中将包含多个虚函数表的指针（即多个****vptr****）。**

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

![20201126113727154.jpeg][]

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

![20201126113727291.jpeg][]

**我们可以看到：**

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

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

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

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

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

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

![20201126113727297.jpeg][]

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

![20201126113727339.jpeg][]

我们可以看见，三个父类虚函数表中的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()

## **虚函数表的内存布局** ##

**虚表其实在数据段。**

对于一个具体类型来说，它的行为是确定的，即对于同一个类型的所有实例，它们的虚函数表的内容相同，在编译时可以确定。因此，如果把虚函数表的全部内容附着在对象实例上，这样的对象模型显然是浪费内存的。因此，在对象实例起始处，放的是一个指针，指向其虚函数表，因此每个对象的虚函数表在实例中仅占一个指针（4 bytes / 32位系统）空间。如果一个类型有多个实例，它们指向的是同一份虚函数表（典型情况是位于进程空间的 .rdata section）。虚函数表指针的初始化由编译器生成的各种构造函数负责。如果一个函数不包含虚函数，则对象实例中不包含虚函数表指针。虚函数表可以认为是由函数指针组成的数组，数组元素由该类型的所有虚函数的地址组成，用 NULL 表示结尾（取决于编译器对模型的实现）。如果该类型实现了自己的虚函数，它将覆盖从父类继承下来的元素。编译器知道表中每个元素对应是那个虚函数，因此调用时取出元素，通过 call 指令实现调用。观察 VC debug 版本的汇编代码，虚函数表的内容被编译到只读的 section（和其他常量字符串一起），每个元素代表的是函数的地址（这些元素是代码段起始部的一组 jump 语句的地址，类似中断向量表，用于跳到真正的函数体）。由于虚函数表位于只读 section 中，所以其元素（函数指针）是不能直接改写的。

## **示例精讲** ##

**class** **A** \{

**public:**

**virtual****void** vfunc1();

**virtual****void** **vfunc2**();

**void** **func1**();

**void** **func2**();

**private:**

**int** m\_data1, m\_data1;

\};

**class** **B****:** **public** A \{

**public:**

**virtual****void** vfunc1();

**void** **func2**();

**private:**

**int** m\_data3;

\};

**class** **C****:** **public** B \{

**public:**

**virtual****void** vfunc1();

**void** **func2**();

**private:**

**int** m\_data1, m\_data4;

\};

以上三个类在内存中的排布关系如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3l1bmZlaTEyMw_size_16_color_FFFFFF_t_70][]

1.  对于非虚函数，三个类中虽然都有一个叫 *func2* 的函数，但他们彼此互不关联，因此都是各自独立的，不存在重载一说，在调用的时候也不需要进行查表的操作，直接调用即可。
2.  由于子类B和子类C都是继承于基类A，因此他们都会存在一个虚指针用于指向虚函数表。**注意**，假如子类B和子类C中不存在虚函数，那么这时他们将共用基类A的一张虚函数表，在B和C中用虚指针指向该虚函数表即可。但是，上面的代码设计时子类B和子类C中都有一个虚函数 *vfunc1*，因此他们就需要各自产生一张虚函数表，并用各自的虚指针指向该表。由于子类B和子类C都对 *vfunc1* 作了重载，因此他们有三种不同的实现方式，函数地址也不尽相同，在使用的时候需要从各自类的虚函数表中去查找对应的 *vfunc1* 地址。
3.  对于虚函数 *vfunc2*，两个子类都没有进行重载操作，所以基类A、子类B和子类C将共用一个 *vfunc2*，该虚函数的地址会分别保存在三个类的虚函数表中，但他们的地址是相同的。
4.  从上图可以发现，在类对象的头部存放着一个虚指针，该虚指针指向了各自类所维护的虚函数表，再通过查找虚函数表中的地址来找到对应的虚函数。
5.  对于类中的数据而言，子类中都会包含父类的信息。如上例中的子类C，它自己拥有一个变量 *m\_data1*，似乎是和基类中的 *m\_data1* 重名了，但其实他们并不存在联系，从存放的位置便可知晓。

**关于动态绑定**

在设计了以上三个类之后，我们就要开始对它们进行使用。  
int main()   
\{  
    B b;  
    b.vfunc1();

A a = (A)b;  
    a.vfunc1();  
\}  
 假如在程序中分别创建两个对象 a 和 b，a的创建是通过将b强制转化为类A得来的。对于 b.vfunc1() 的调用，应该没有太的疑问，它所调用的就是类B中的 vfunc1。**而对于 a.vfunc1() 的调用，它虽然是强制转化后的结果，但并不能改变它是一个类A对象的事实，因此这里调用的便是类A中的 vfunc1，也就是上图中显示绿色的函数。**  
int main()   
\{  
    A\* pa = new B;  
    pa->vfunc1();

B b;  
    pa = &b;  
    pa->vfunc1();  
\}  
 将程序改写成以上内容，pa 是一个类A的指针，但它指向的是一个类B的对象。在使用pa调用 vfunc1 的时候，程序发现pa是一个指针，并且现在正在调用一个虚函数叫做 vfunc1，这时通过 pa->vptr 这个虚指针到类B的虚函数中（上图的B vtbl）找对应的虚函数地址，找到该地址以后，就用相应的虚函数来进行调用，也就是调用上图所示的 B::vfunc1()。  
**pa是类A的指针，为什么查找的是类B的虚函数表？**  
只要某一个类X包含虚函数，无论是它的父类或者它本身拥有，那么这个类的对象都会包含一个虚指针vptr，至于vptr要指向哪张表，取决于类X它本身是否含有虚函数。此处，类B中存在虚函数，那么它就会拥有自己的一张虚函数表。pa指向的是一个类B的对象，因此 p-vptr 指代的是类B中虚指针，所以它查找的是类B的虚函数表

**如何从虚函数表中查找到 vfunc1 的地址？**  
虚函数表中的内容是在编译的时候确定的，通过以下方式进行查找 (\* p->vptr\[n\] )(p) 或者 (\* (p->vptr)\[n\] )(p)，它的解读是：通过类对象指针p找到虚指针vptr，再查找到虚函数表中的第n个内容，并将他作为函数指针进行调用，调用时的入参是p(式子中的第二个p)，而这个p就是隐藏的this指针，这里的n也是在编译的时候确定的。  
int main()  
\{  
    A a;  
    B b;

A\* p1 = &a;  
    p1->vfunc1();

A\* p2 = &b;  
    p2->vfunc1();  
\}  
 再将程序修改成以上内容，对于 p2->vfunc1() 的调用和上文所述一致，它调用的是 B::vfunc1 函数。而对于 p1->vfunc1() 的调用，同样通过上面的方法可知， p1->vptr 它所指向的是类A的虚函数表，因此它调用的是 A::vfunc1 函数。  
 通过以上内容，我们可以知道在使用基类指针调用虚函数的时候，它能够根据所指的类对象的不同来正确调用虚函数。而这些能够正常工作，得益于虚指针和虚函数表的引入，使得在程序运行期间能够动态调用函数。  
动态绑定有以下三项条件要符合：  
1.    使用指针进行调用  
2.    指针属于up-cast后的  
3.    调用的是虚函数  
与动态绑定相对应的是静态绑定，它属于编译的时候就确定下来的，如上文的非虚函数，他们是类对象直接可调用的，而不需要任何查表操作，因此调用的速度也快于虚函数。

[20201126113727153.jpeg]: /images/20210923/93f782fceb4a4003b7e7727fa66d5cfa.png
[20201126113727299.jpeg]: /images/20210923/ee2f3b090c764df9af07777c8ee99da3.png
[20201126113727293.jpeg]: /images/20210923/88e8d04997704e4ca6cde0fae9299f44.png
[20201126113727335.jpeg]: /images/20210923/0e38293b66ef4513a51c7c37c8fab6a4.png
[20201126113727154.jpeg]: /images/20210923/bfb3fafe44f645389ede513c988e4064.png
[20201126113727291.jpeg]: /images/20210923/8d1076667f824e47b72be6cc3d1d3c86.png
[20201126113727297.jpeg]: /images/20210923/de4cf7adcbcb40db84be6490b83b2b04.png
[20201126113727339.jpeg]: /images/20210923/6900580b782043ad8350317795118911.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3l1bmZlaTEyMw_size_16_color_FFFFFF_t_70]: /images/20210923/6900580b782043ad8350317795118911.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3l1bmZlaTEyMw==,size_16,color_FFFFFF,t_70