虚函数表结构

虚函数表

所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。

我们可以通过下示的代码简单看下虚函数表结构：

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

	int D;
};

int main(){
	Base* b1 = new Base;
	return 0;
}

这里有个问题：为什么b1中没有成员函数 C 的信息？

因为成员函数在编译期间确定，对象在调用时直接call函数名去调用，所以不需要在对象中存储成员函数信息。

单继承下的虚函数表

在了解了虚函数表在单个实例化对象中的结构后，我们看一下在单继承下的虚函数表。

• 未覆盖

这里所提到的覆盖也就是常说的重写是指：派生类在继承父类虚函数之后有没有重载基类的函数，如果有就会发生覆盖，反之。

同样，我们运行下述代码进行实验：

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

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

int main(){
        Base b1;
	Derive d1;

	return 0;
}

但结果并不是我们所想的那样：

这里面没有我们派生类的虚函数指针。这是因为编译器故意隐藏了这两个函数。

不过我们可以在通过代码打印出来。

思路：取出b1、d1对象的头4bytes，就是虚表的指针，而虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
     1.先取b1的地址，强转成一个int*的指针；
     2.再解引用取值，就取到了b1对象头4bytes的值，这个值就是指向虚表的指针；
     3.再强转成pVtable*，因为虚表就是一个存虚函数指针类型的数组；
     4.虚表指针传递给PrintVTable进行打印虚表；
     5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。

代码实现：

typedef void(*pVtable)(void);

void PrintVTable(pVtable vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		pVtable f = vTable[i];
		f();
	}
	cout << endl;
}

int main(){
	Base b1;
	Derive d1;
	pVtable* vTableb = (pVtable*)(*(int*)&b1);
	PrintVTable(vTableb);
	pVtable* vTabled = (pVtable*)(*(int*)&d1);
	PrintVTable(vTabled);

	return 0;
}

执行结果：

如果发生如下图所示错误，中断-->生成-->清理解决方案-->重新生成解决方案   就OK了：

结论：

1. 虚函数按照其声明顺序放于表中。
2. 父类的虚函数在子类的虚函数前面。

• 覆盖

一般来讲基类声明虚函数就是为了让派生类重写，所以我们了解下重写之后的虚函数表。

只需在派生类重写下基类的方法：

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

执行完结果，明显看出此时派生类对象中派生类虚函数地址已将基类虚函数地址覆盖掉了，而没有重写的虚函数B依然与基类地址相同：

结论：

如果派生类对基类的虚函数进行重写，则将被重写的虚函数地址覆盖为派生类的函数地址。其他未被覆盖的保持不变。

 

多继承下的虚函数表：

看完单继承自然而然开始讨论多继承下的虚函数表，同样分为两种情况讨论：

• 未覆盖

在之前代码中添加Base2类，并让Derive继承Base2，创建Base2对象b2。

class Base{
public:
	virtual void A(){ cout << "Base::A()" << endl; }
	virtual void B(){ cout << "Base::B()" << endl; }
};
class Base2{
	virtual void A(){ cout << "Base::A()" << endl; }
	virtual void B(){ cout << "Base::B()" << endl; }
};
class Derive :public Base, public Base2{
public:
	virtual void C(){ cout << "Derive::C()" << endl; }
	virtual void D(){ cout << "Derive::D()" << endl; }
};

由于多继承下派生类会产生多个虚表，就本例而言会有两个虚表如下图所示：

所以我们要取两次虚表地址：

	pVtable* vTabled = (pVtable*)(*(int*)&d1);
	PrintVTable(vTabled);
	vTabled = (pVtable*)(*(int*)((char* )&d1+sizeof(Base)));
	PrintVTable(vTabled);

执行结果：

如果我们将继承顺序颠倒：

class Derive :public Base2, public Base{
public:
	virtual void C(){ cout << "Derive::C()" << endl; }
	virtual void D(){ cout << "Derive::D()" << endl; }
};

执行结果：

结论：

1. 每个基类都要一张虚函数表，且在派生类中按序排放（这里的按序指声明顺序）；
2. 派生类自己的虚函数地址存放在第一张虚函数表中。（这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。）

• 覆盖

最后在看看多继承下覆盖后的虚函数表，结合之前示例实现此过程就很容易，不再贴代码直接运行出结果：

结论：

基类虚函数A()位置被替换成了派生类的函数指针。这样，我们就可以任一静态类型的基类来指向派生类，并调用派生类的A()了。