C++虚函数表深入探索(详细全面)

  • Post author:
  • Post category:其他


这篇博客可能有一点点长,代码也有一点点多,但是仔细阅读分析完,会对虚函数表有一个深刻的认识。

什么是虚函数表?

对于一个类来说,

如果类中存在虚函数,那么该类的大小就会多4个字节,然而这4个字节就是一个指针的大小,这个指针指向虚函数表

。所以,如果对象存在虚函数,那么编译器就会生成一个指向虚函数表的指针,所有的虚函数都存在于这个表中,

虚函数表就可以理解为一个数组,每个单元用来存放虚函数的地址



虚函数(Virtual Function)是通过一张虚函数表来实现的

。简称为V-Table。在这个表中,主要是一个类的虚函数的地址表,

这张表解决了继承、覆盖的问题,保证其真实反应实际的函数

。这样,在有虚函数的类的实例中分配了指向这个表的指针的内存,所以,当用父类的指针来操作一个子类的时候,这张虚函数表就显得尤为重要了,它就像一个地图一样,指明了实际所应该调用的函数。                                                                                                                                   ————-百度百科

虚函数表存在的位置

由于虚函数表是由编译器给我们生成的,那么编译器会把虚函数表安插在哪个位置呢?下面可以简单的写一个示例来证明一下虚函数表的存在,以及观察它所存在的位置,先来看一下代码:

#include <iostream>
#include <stdio.h>
using namespace std;

class A{
public:
	int x;
	virtual void b() {}
};

int main()
{
	A* p = new A;
	cout << p << endl;
	cout << &p->x << endl;
	return 0;
}

定义了一个类A,含有一个x和一个虚函数,实例化一个对象,然后输出对象的地址和对象成员x的地址,我们想一下,如果对象的地址和x的地址相同,那么就意味着编译器把虚函数表放在了末尾,如果两个地址不同,那么就意味着虚函数表是放在最前面的。运行结果为16进制,然后我们把它转为10进制观察一下:

可以观察到结果是不同的,而且正好相差了4个字节,由此可见,

编译器把生成的虚函数表放在了最前面

获取虚函数表

既然虚函数表是真实存在的,那么我们能不能想办法获取到虚函数表呢?其实我们可以通过指针的形式去获得,因为前面也提到了,我们可以把虚函数表看作是一个数组,每一个单元用来存放虚函数的地址,那么当调用的时候可以直接通过指针去调用所需要的函数就行了。我们就类比这个思路,去获取一下虚函数表。首先先定义两个类,一个是基类一个是派生类,代码如下:

class Base {
public:
	virtual void a() { cout << "Base a()" << endl; }
	virtual void b() { cout << "Base b()" << endl; }
	virtual void c() { cout << "Base c()" << endl; }
};

class Derive : public Base {
public:
	virtual void b() { cout << "Derive b()" << endl; }
};

现在我们设想一下Derive类中的虚函数表是什么样的,它应该是含有三个指针,分别指向基类的虚函数a和基类的虚函数c和自己的虚函数b(因为基类和派生类中含有同名函数,被覆盖),那么我们就用下面的方式来验证一下:

    Derive* p = new Derive;
	long* tmp = (long*)p;             // 先将p强制转换为long类型指针tmp

	// 由于tmp是虚函数表指针,那么*tmp就是虚函数表
	long* vptr = (long*)(*tmp);
	for (int i = 0; i < 3; i++) {
		printf("vptr[%d] : %p\n", i, vptr[i]);
	}

同理,我们把基类的虚函数表的内容也用这种方法获取出来,然后二者进行比较一下,看看是否是符合我们上面所说的那个情况。先看一下完整的代码:

#include <iostream>
#include <stdio.h>
using namespace std;

class Base {
public:
	virtual void a() { cout << "Base a()" << endl; }
	virtual void b() { cout << "Base b()" << endl; }
	virtual void c() { cout << "Base c()" << endl; }
};

class Derive : public Base {
public:
	virtual void b() { cout << "Derive b()" << endl; }
};

int main()
{
	cout << "-----------Base------------" << endl;
	Base* q = new Base;
	long* tmp1 = (long*)q;
	long* vptr1 = (long*)(*tmp1);
	for (int i = 0; i < 3; i++) {
		printf("vptr[%d] : %p\n", i, vptr1[i]);
	}

	Derive* p = new Derive;
	long* tmp = (long*)p;
	long* vptr = (long*)(*tmp);
	cout << "---------Derive------------" << endl;
	for (int i = 0; i < 3; i++) {
		printf("vptr[%d] : %p\n", i, vptr[i]);
	}
	return 0;
}

运行结果如下图所示:

可见基类中的三个指针分别指向a,b,c虚函数,而派生类中的三个指针中第一个和第三个和基类中的相同,那么这就印证了上述我们所假设的情况,那么这也就是虚函数表。但是仅仅只是观察指向的地址,还不是让我们观察的特别清楚,那么我们就通过定义函数指针,来调用一下这几个地址,看看结果是什么样的,下面直接上代码:

#include <iostream>
#include <stdio.h>
using namespace std;

class Base {
public:
	virtual void a() { cout << "Base a()" << endl; }
	virtual void b() { cout << "Base b()" << endl; }
	virtual void c() { cout << "Base c()" << endl; }
};

class Derive : public Base {
public:
	virtual void b() { cout << "Derive b()" << endl; }
};

int main()
{
	typedef void (*Func)();
	cout << "-----------Base------------" << endl;
	Base* q = new Base;
	long* tmp1 = (long*)q;
	long* vptr1 = (long*)(*tmp1);
	for (int i = 0; i < 3; i++) {
		printf("vptr[%d] : %p\n", i, vptr1[i]);
	}
	Func a = (Func)vptr1[0];
	Func b = (Func)vptr1[1];
	Func c = (Func)vptr1[2];
	a();
	b();
	c();

	Derive* p = new Derive;
	long* tmp = (long*)p;
	long* vptr = (long*)(*tmp);
	cout << "---------Derive------------" << endl;
	for (int i = 0; i < 3; i++) {
		printf("vptr[%d] : %p\n", i, vptr[i]);
	}
	Func d = (Func)vptr[0];
	Func e = (Func)vptr[1];
	Func f = (Func)vptr[2];
	d();
	e();
	f();

	
	return 0;
}

运行结果如下:

这样就清晰的印证了上述所说的假设,那么虚函数表就获取出来了。

多重继承的虚函数表:

虚函数的引入其实就是为了实现多态(对于多态看到了一篇很不错的博客:

传送门

),现在来研究一下多重继承的虚函数表是什么样的,首先我们先来看一下简单的一般继承的代码:

class Base1 {
public:
	virtual void A() { cout << "Base1 A()" << endl; }
	virtual void B() { cout << "Base1 B()" << endl; }
	virtual void C() { cout << "Base1 C()" << endl; }
};

class Derive : public Base1{
public:
	virtual void MyA() { cout << "Derive MyA()" << endl; }
};

这是一个类继承一个类,这段代码如果我们通过派生类去调用基类的函数,应该结果可想而知,这里就不再演示和赘述了。我们来分析这两个类的虚函数表,

对于基类的虚函数表其实和上面所说的虚函数表是一样的,有自己的虚函数指针,并指向自己的虚函数表

,重点是在于派生类的虚函数表是什么样子的,它的样子如下图所示:

那么

Derive的虚函数表就是继承了Base1的虚函数表,然后自己的虚函数放在后面,因此这个虚函数表的顺序就是基类的虚函数表中的虚函数的顺序+自己的虚函数的顺序

。那么我们现在在Derive中再添加一个虚函数,让它覆盖基类中的虚函数,代码如下:

class Base1 {
public:
	virtual void A() { cout << "Base1 A()" << endl; }
	virtual void B() { cout << "Base1 B()" << endl; }
	virtual void C() { cout << "Base1 C()" << endl; }
};

class Derive : public Base1{
public:
	virtual void MyA() { cout << "Derive MyA()" << endl; }
	virtual void B() { cout << "Derive B()" << endl; }
};

那么对于这种情况的虚函数表如下图所示:

这个是单继承的情况,然后我们看看多重继承,也就是Derive类继承两个基类,先看一下代码:

class Base1 {
public:
	virtual void A() { cout << "Base1 A()" << endl; }
	virtual void B() { cout << "Base1 B()" << endl; }
	virtual void C() { cout << "Base1 C()" << endl; }
};

class Base2 {
public:
	virtual void D() { cout << "Base2 D()" << endl; }
	virtual void E() { cout << "Base2 E()" << endl; }
};

class Derive : public Base1, public Base2{
public:
	virtual void A() { cout << "Derive A()" << endl; }           // 覆盖Base1::A()
	virtual void D() { cout << "Derive D()" << endl; }           // 覆盖Base2::D()
	virtual void MyA() { cout << "Derive MyA()" << endl; }
};

首先我们明确一个概念,

对于多重继承的派生类来说,它含有多个虚函数指针,对于上述代码而言,Derive含有两个虚函数指针

,所以它不是只有一个虚函数表,然后把所有的虚函数都塞到这一个表中,为了印证这一点,我们下面会印证这一点,首先我们先来看看这个多重继承的图示:

由图可以看出,在第一个虚函数表中首先继承了Base1的虚函数表,然后将自己的虚函数放在后面,对于第二个虚函数表中,继承了Base2的虚函数表,由于在Derive类中有一个虚函数D覆盖了Base2的虚函数,所以第一个表中就没有Derive::D的函数地址。那么我们就用代码来实际的验证一下是否会存在两个虚函数指针,以及如果存在两个虚函数表,那么虚函数表是不是这个样子的。来看下面的代码:

#include <iostream>
#include <stdio.h>
using namespace std;

class Base1 {
public:
	virtual void A() { cout << "Base1 A()" << endl; }
	virtual void B() { cout << "Base1 B()" << endl; }
	virtual void C() { cout << "Base1 C()" << endl; }
};

class Base2 {
public:
	virtual void D() { cout << "Base2 D()" << endl; }
	virtual void E() { cout << "Base2 E()" << endl; }
};

class Derive : public Base1, public Base2{
public:
	virtual void A() { cout << "Derive A()" << endl; }           // 覆盖Base1::A()
	virtual void D() { cout << "Derive D()" << endl; }           // 覆盖Base2::D()
	virtual void MyA() { cout << "Derive MyA()" << endl; }
};

int main()
{
	typedef void (*Func)();
	Derive d;
	Base1 &b1 = d;
	Base2 &b2 = d;
	cout << "Derive对象所占的内存大小为:" << sizeof(d) << endl;
	
	cout << "\n---------第一个虚函数表-------------" << endl;
	long* tmp1 = (long *)&d;              // 获取第一个虚函数表的指针
	long* vptr1 = (long*)(*tmp1);         // 获取虚函数表

	Func x1 = (Func)vptr1[0];
	Func x2 = (Func)vptr1[1];
	Func x3 = (Func)vptr1[2];
	Func x4 = (Func)vptr1[3];
	x1();x2();x3();x4();

	cout << "\n---------第二个虚函数表-------------" << endl;
	long* tmp2 = tmp1 + 1;               // 获取第二个虚函数表指针 相当于跳过4个字节
	long* vptr2 = (long*)(*tmp2);

	Func y1 = (Func)vptr2[0];
	Func y2 = (Func)vptr2[1];
	y1(); y2();

	return 0;
}

先看看运行结果,然后再去分析证明:

因为在包含一个虚函数表的时候,含有一个虚函数表指针,所占用的大小为4个字节,那么这里输出了8个字节,就说明Derive对象含有两个虚函数表指针。然后我们通过获取到了这两个虚函数表,并调用其对应的虚函数,可以发现输出的结果和上面的示例图是相同的,因此就证明了上述所说的结论是正确的。


简单的总结一下:


1. 每一个基类都会有自己的虚函数表,派生类的虚函数表的数量根据继承的基类的数量来定。


2. 派生类的虚函数表的顺序,和继承时的顺序相同。


3. 派生类自己的虚函数放在第一个虚函数表的后面,顺序也是和定义时顺序相同。


4. 对于派生类如果要覆盖父类中的虚函数,那么会在虚函数表中代替其位置。

虚函数指针和虚函数表的创建时机:

对于虚函数表来说,在编译的过程中编译器就为含有虚函数的类创建了虚函数表,并且编译器会在构造函数中插入一段代码,这段代码用来给虚函数指针赋值。因此

虚函数表是在编译的过程中创建

对于虚函数指针来说,由于虚函数指针是基于对象的,所以对象在实例化的时候,虚函数指针就会创建,所以

是在运行时创建

。由于在实例化对象的时候会调用到构造函数,所以就会执行虚函数指针的赋值代码,从而将虚函数表的地址赋值给虚函数指针。

虚函数表的深入探索:

经过上面的学习说明,我们知道了虚函数表的作用,是用来存放虚函数的地址的,那么我们先来看一下这个代码:

#include <iostream>
using namespace std;

class A{
public:
	int x;
	A(){
		memset(this, 0, sizeof(x));       // 将this对象中的成员初始化为0
		cout << "构造函数" << endl;
	}
	A(const A& a) {
		memcpy(this, &a, sizeof(A));      // 直接拷贝内存中的内容
		cout << "拷贝构造函数" << endl;
	}
	virtual void virfunc() {
		cout << "虚函数func" << endl;
	}
	void func() {
		cout << "func函数" << endl;
	}
	virtual ~A() {
		cout << "析构函数" << endl;
	}
};

int main()
{
	A a;
	a.virfunc();
	return 0;
}

在构造函数中用的是memset()函数进行初始化操作,在拷贝构造函数中使用memcpy的方式来拷贝,可能这样的方法效率会更高,其运行结果如下图所示:

可以运行,但是我们要对代码进行分析,前面我们提到了虚函数表是在编译的时候就已经生成好了,那么对于上面的代码中的virfunc来说,它的地址就已经存在于虚函数表中了,又根据前面我们提到的,在实例化对象的时候,编译器会为构造函数中插入一些代码,这些代码用来给虚函数指针进行赋值,那么这些操作都是在我们执行memset之前进行的,因此在执行了这些操作后,调用了memset函数,使得所有内容都清空了,那么虚函数指针就指向了0,那为什么我们还可以调用virfunc函数和析构函数呢?

这里就涉及到了静态联编和动态联编的问题,我们先来明确一下静态联编和动态联编的定义:


静态联编:在编译时所进行的这种联编又称静态束定,在编译时就解决了程序中的操作调用与执行该操作代码间的关系。


动态联编:编译程序在编译阶段并不能确切知道将要调用的函数,只有在程序运行时才能确定将要调用的函数,为此要确                      切知道该调用的函数,要求联编工作要在程序运行时进行,这种在程序运行时进行联编工作被称为动态联编。



由于我们把虚函数表指针设为了0,所以我们就无法通过前面的方法来获取它,这里我们可以通过反汇编来查看virfunc的地址:

我们发现virfunc函数的地址并不是我们设置的0,那么它就变的和普通的函数没有什么区别了(普通函数采用静态联编,在编译时就绑定了函数的地址),这显然不是我们想要的虚函数,那么肯定就无法实现多态,

对于类的多态性,一定是基于虚函数表的,那么虚函数表的实现一定是动态联编的,因此也不可缺少虚函数指针寻址的过程,那么我们要实现动态联编,就需要用到指针或者引用的形式。

如果按上面代码的方式去执行,由于是非指针非引用的形式,所以编译器采用了静态绑定,提前绑定了函数的地址,那么就不存在指针寻址的过程了;如果使用指针或引用的形式,那么由于对象的所属类不能确定,那么编译器就无法采用静态编联,所以就只有通过动态编联的方式,在运行时去绑定调用指针和被调用地址。那么我们把代码改成下面的样子:

A *a = new A;
a.virfunc();

这个时候我们再运行程序,由于我们将虚函数指针置为0,从而找不到了虚函数的位置,那么程序就会崩溃,然后我们再通过反汇编查看一下,如图所示:

比之前的多了一些汇编指令,其中mov就是寻址的过程,这样就实现了动态绑定,也是根据这一点来实现多态性,这里我只用了一个类来进行展示说明,其实用两个类更好。总之,

如果要实现虚函数和多态,就需要通过指针或者引用的方式

关于虚函数表的东西就是这么多,如果有错误或者遗漏或者有疑问的地方可以在评论区中指出,这篇博客主要是自己学习后的一个总结,对于讲解部分,感觉图片太少了,单纯用文字描述又过于抽象,以后应该要加以改正。



版权声明:本文为Charles_Zaqdt原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。