深度探索C++对象模型（9）——虚函数（2）——多重继承的虚函数表、vptr和vtbl的创建时机

1.多重继承的虚函数表

代码：

#include 
using namespace std;

//基类1
class Base1
{
public:
	virtual void f()
	{
		cout << "base1::f()" << endl;
	}
	virtual void g()
	{
		cout << "base1::g()" << endl;
	}
};

//基类2
class Base2
{
public:
	virtual void h()
	{
		cout << "base2::h()" << endl;
	}
	virtual void i()
	{
		cout << "base2::i()" << endl;
	}
};

//子类
class Derived :public Base1, public Base2
{
public:
	virtual void f() //覆盖父类1的虚函数
	{
		cout << "derived::f()" << endl;
	}
	virtual void i() //覆盖父类2的虚函数
	{
		cout << "derived::i()" << endl;
	}

	//如下三个是子类自己的虚函数
	virtual void mh()
	{
		cout << "derived::mh()" << endl;
	}

	virtual void mi()
	{
		cout << "derived::mi()" << endl;
	}

	virtual void mj()
	{
		cout << "derived::mj()" << endl;
	}
};



int main()
{

	cout << sizeof(Base1) << endl;
	cout << sizeof(Base2) << endl;
	cout << sizeof(Derived) << endl;

	Derived ins;
	Base1 &b1 = ins; //多态
	Base2 &b2 = ins;
	Derived &d = ins;

	typedef void(*Func)(void);
	long *pderived1 = (long *)(&ins);
	long *vptr1 = (long *)(*pderived1); //取第一个虚函数表指针。

	long *pderived2 = pderived1 + 1; //跳过4字节
	long *vptr2 = (long *)(*pderived2); //取第二个虚函数表指针。

	Func f1 = (Func)vptr1[0];//Derived::f(void)}
	Func f2 = (Func)vptr1[1];//Base1::g(void)}
	Func f3 = (Func)vptr1[2];//Derived::mh(void)}
	Func f4 = (Func)vptr1[3];//Derived::mi(void)}
	Func f5 = (Func)vptr1[4];//Derived::mj(void)}
	Func f6 = (Func)vptr1[5]; //非正常
	

	Func f11 = (Func)vptr2[0]; //Base2::h(void)}
	Func f22 = (Func)vptr2[1]; //Derived::i(void)}
	Func f33 = (Func)vptr2[2]; //非正常

	b1.f();
	b2.i();
	d.f();
	d.i();
	d.mh();
	d.g();

	//----------------
	cout << "-----------------" << endl;
	f1();
	f2();
	f3();
	f4();
	f5();
	cout << "-------------" << endl;
	f11();
	f22();

	return 1;
}

VS2017下结果：

Linux下g++编译器下结果：

解释：

（1）两个基类Base1,Base2在产生对象的时候，各自有一个虚函数表指针，所以均为4个字节，而子类继承了两个类，有两个虚函数表指针，所以有8个字节；

（2）“long *pderived2 = pderived1 + 1;”中+1加的是指针的大小，在VS2017中给指针+1跳4个字节，在Linux下给指针+1跳8个字节;

（3）下面对对象b1,b2,d中函数的调用都是对子类对象函数的调用，f(),i()都覆盖了基类的函数，所以b1.f(),和b2.i()都是调用子类覆盖之后的函数

（4）一个对象，如果它的类有多个基类则有多个虚函数表指针（注意是两个虚函数表指针，而不是两个虚函数表）；
    在多继承中，对应各个基类的vptr按继承顺序依次放置在类的内存空间中，且子类与第一个基类共用一个vptr(第二个基类有自己的vptr);

（5）VS2017中第一个虚函数表中没有子类覆盖了Base2中的虚函数i()，而在Linux的g++编译器下有子类中定义的所有虚函数，不管它继承自哪个基类

（6）对应于VS2017结果的图：

<1>子类对象ins有里那个虚函数表指针，vptr1,vptr2

<2>类Derived有两个虚函数表，因为它继承自两个基类；

<3>子类和第一个基类公用一个vptr（因为vptr指向一个虚函数表，所以也可以说子类和第一个基类共用一个虚函数表vtbl),
        因为我们注意到了类Derived的虚函数表1里边的5个函数，而g()正好是base1里边的函数。

<4>子类中的虚函数覆盖了父类中的同名虚函数。比如derived::f(),derived::i();

2.查看虚函数表的辅助工具

VS下：

（1）打开VS 2017开发人员命令提示符

（2）进入项目所在文件夹

从这里打开查看项目文件所在路径

比如我的在F盘，

<1>在命令界面先输入F:来进入F盘

<2>再输入命令   cd 上一步的路径

（3）用cl.exe（编译链接工具）打开test1.cpp

输入上述命令

注意cl中是字母l,d1中是数字1

后面两个分别是你想查看的类以及类所在的cpp文件

（4）出现这样的结果进行分析即可

3.vptr和vtbl的创建时机

（1）vptr(虚函数表指针）什么时候创建出来的？

vptr跟着对象走，所以对象什么时候创建出来，vptr就什么时候创建出来，即运行的时候创建；
实际上，对于这种有虚函数的类，在编译的时候，编译器会往相关的构造函数中增加为vptr赋值的代码，这是在编译期间编译器为构造函数增加的。这属于编译器默默为我们做的事，我们并不清楚。当程序运行的时候，遇到创建对象的代码，执行对象的构造函数，那么这个构造函数里有 给对象的vptr(成员变量)赋值的语句，自然这个对象的vptr就被赋值了；

（2）虚函数表是什么时候创建的？

    实际上，虚函数表是编译器在编译期间（不是运行期间）就为每个类确定好了对应的虚函数表vtbl的内容（编译期间就生成了存放虚函数表的目标文件）
    然后也是在编译器期间在相应的类构造函数中添加给vptr赋值的代码，这样程序运行的时候，当运行到成成类对象的代码时，会调用类的构造函数，执行到类的构造函数中的 给vptr赋值的代码，这样这个类对象的vptr(虚函数表指针)就有值了；

虚函数执行的内存分析：

创建的A对象指针obj指向堆中new出来的对象，

该对象中有虚函数表指针指向虚函数表首地址，

虚函数表中存放着指向代码段的中对应虚函数的首地址