深入探究c++虚函数表原理，继承与多态的实现

---

虚函数表简介

虚函数（Virtual Function）是通过一张虚函数表来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中分配了指向这个表的指针的内存，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得尤为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
编译器保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着可以通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。
这里需要注意的是每个类有且只有一张虚函数表，供所有的对象共享，类在构造对象的时候，把指向虚函数表的指针（即虚指针）存放到对象内存开始的地方，即对象实例的地址，即类不管有多少的虚函数，都只通过指找到虚函数表进行访问

---

一、通过虚函数指针得到虚函数表

设计Base类如下：

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 b,a;
cout << "Base虚函数表指针地址：" << (int*)&b << endl;
cout << "Base虚函数表地址：" << (int*)*(int*)(&b) << endl;

这里需要明确一下：**对象的地址是指向虚函数表的虚指针的地址，*在32为编译系统中将指针转成(int )型，虚指针里存放的才是虚函数的地址，继续对虚指针解引用才得到虚函数表的地址，可以把虚函数表看成数组，即得到数组的首地址。

二、所有对象共享虚函数表

之前看网上博客，对此有争议：究竟是每个类只有一张表还是说每个对象都有分别有一张表，从类设计以及资源管理的角度，很明显不可能每个对象都有一张表，对此，也比较容易的可以验证

Base b,a;
	
	//cout << "Base虚函数表指针地址：" << (int*)&b << endl;
	//cout << "Base虚函数表地址：" << (int*)*(int*)(&b) << endl;
	
	cout << "Base b 虚函数表地址：" << (int*)*(int*)(&b) << endl;
	cout << "Base a 虚函数表地址：" << (int*)*(int*)(&a) << endl;  // 结论：同一类不同对象的虚函数表是同一个，即同类对象共享一个虚函数表
	cout << "sizeof Base:" << sizeof(Base) << endl;  // 4

运行效果如下：

a,b两个Base对象，虚函数表地址一模一样，而且当对Base类进行sizeof操作的时候，32位编译系统中才4个字节，也就是一个指针的大小，即虚指针，也就是仅仅是虚函数表地址的大小，4个字节。所以，验证了结论，同一类不同对象的虚函数表是同一个，即同类对象共享一个虚函数表。

三、遍历虚函数表，调用相应的函数

前文说到，可以把虚函数表看成一个数组，那么遍历虚函数表就是遍历数组的操作。虚函数表中存放的是一个个虚函数的函数指针，故我们定义函数指针以方便遍历：

typedef void (*pFUN)();

既然虚函数表可以看成数组，那么对数组的访问就有两种方式：直接用下标进行访问，与用指针解引用进行访问，比如看个小例子

int x[5] = { 1,2,3,4,5 };
cout << x[1] << endl << *(x + 1) << endl;

结果是一样的，所以，对虚函数表进行访问的代码如下，将指针转换成pFUN型，然后调用函数指针

// 虚函数表地址看成数组首地址，存放着一个个虚函数的指针
	int* vtable_addr = (int*)*(int*)(&b);
	pFUN p1 = (pFUN) vtable_addr[0];
	pFUN p2 = (pFUN) *((int*)*(int*)(&b)+1);
	pFUN p3 = (pFUN) *((int*)*(int*)(&b)+2);
	p1();
	p2();
	p3();

运行结果如下：

到此位置，已经访问但虚函数，说来复杂，其实也简单，看鄙人画的下面一张图：

四、继承与多态的实现，子类的虚函数表

定义子类如下

class Son :public Base {
public:
	virtual void s1() { cout << "Son::s1()" << endl; }
	virtual void g() { cout << "Son::g()" << endl; }
};

class Daughter :public Base {
public:
	virtual void d1() { cout << "Daughter::d1()" << endl; }
	virtual void d2() { cout << "Daughter::d2()" << endl; }
};

其中，Son子类覆盖了Base的虚函数g，Daughter子类并没有覆盖Base的任何虚函数，事实上，对于Daughter类来说，他的虚函数表有五个虚函数，分别是父类的三个虚函数f,g,h,以及自己的两个虚函数d1,d2可以编写代码进行测试

编写代码进行测试：

	cout << "------------------测试 Daughter---------------" << endl;
	Daughter d;
	int* vtable_dau_addr = (int*)*(int*)(&d);
	for (int i = 0; i < 5; ++i) {
		pFUN p = (pFUN)vtable_dau_addr[i];
		p();
	}

事实上，对于Son类来说，他的虚函数表有4个虚函数，分别是父类未被覆盖的2个虚函数f,h,以及覆盖了的父类虚函数g,以及自身的s1，在执行时，覆盖了父类的虚函数将执行覆盖后自身的函数

cout << "-----------------测试 Son----------------" << endl;
	Son s;
	int* vtable_son_addr = (int*)*(int*)(&s);
	for (int i = 0; i < 4; ++i) {
		pFUN p = (pFUN)vtable_son_addr[i];
		p();
	}

可以看出，所谓继承，无非就是将父类的虚函数继承到子类，即在子类的虚函数表中加入父类的虚函数。
所谓多态，无非是子类重载父类的虚函数后，在虚函数表中将同名父类的虚函数指针换成子类的虚函数指针，仅此而已。

cout << "------------------测试多态--------------" << endl;
	Base* t = new Son();
	t->f();
	t->g();

完整的测试代码如下，运行环境vs2019 debug x86

#include <iostream>

using namespace std;

typedef void (*pFUN)();
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 Son :public Base {
public:
	virtual void s1() { cout << "Son::s1()" << endl; }
	virtual void g() { cout << "Son::g()" << endl; }
};

class Daughter :public Base {
public:
	virtual void d1() { cout << "Daughter::d1()" << endl; }
	virtual void d2() { cout << "Daughter::d2()" << endl; }
};

int main() {

	Base b,a;
	//int x[5] = { 1,2,3,4,5 };
	//cout << x[1] << endl << *(x + 1) << endl;
	//cout << "Base虚函数表指针地址：" << (int*)&b << endl;
	//cout << "Base虚函数表地址：" << (int*)*(int*)(&b) << endl;
	
	cout << "Base b 虚函数表地址：" << (void*)*(int*)(&b) << endl;
	cout << "Base a 虚函数表地址：" << (void*)*(int*)(&a) << endl;  // 结论：同一类不同对象的虚函数表是同一个，即同类对象共享一个虚函数表
	cout << "sizeof Base:" << sizeof(Base) << endl;  // 4

	// 虚函数表地址看成数组首地址，存放着一个个虚函数的指针
	int* vtable_addr = (int*)*(int*)(&b);
	pFUN p1 = (pFUN) vtable_addr[0];
	pFUN p2 = (pFUN) *((int*)*(int*)(&b)+1);
	pFUN p3 = (pFUN) *((int*)*(int*)(&b)+2);
	p1();
	p2();
	p3();

	cout << "-----------------测试 Son----------------" << endl;
	Son s;
	int* vtable_son_addr = (int*)*(int*)(&s);
	for (int i = 0; i < 4; ++i) {
		pFUN p = (pFUN)vtable_son_addr[i];
		p();
	}

	cout << "------------------测试 Daughter---------------" << endl;
	Daughter d;
	int* vtable_dau_addr = (int*)*(int*)(&d);
	for (int i = 0; i < 5; ++i) {
		pFUN p = (pFUN)vtable_dau_addr[i];
		p();
	}
	cout << "------------------测试多态--------------" << endl;
	Base* t = new Son();
	t->f();
	t->g();

	system("pause");
	return 0;
}