深度探索C++对象模型（14）——数据语义学（4）——多重继承数据布局与this调整深谈

1.多重继承数据布局

代码1：

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

class Base1
{
public:
	int m_bi;
	virtual void mybvirfunc() {}

	Base1()
	{
		printf("Base1::Base1()的this指针是：%p!\n", this);
	}
};
class Base2
{
public:
	int m_b2i;
	virtual void mybvirfunc2() {}

	Base2()
	{
		printf("Base2::Base2()的this指针是：%p!\n", this);
	}
};
class MYACLS :public Base1, public Base2
{
public:
	int m_i;
	int m_j;

	virtual void myvirfunc() {} //虚函数
	MYACLS()
	{
		int abc = 1; 
		printf("MYACLS::MYACLS()的this指针是：%p!\n", this);
	}
	~MYACLS()
	{
		int def = 0;
	}
};


int main()
{
	cout << sizeof(MYACLS) << endl;
	printf("MYACLS::m_bi = %d\n", &MYACLS::m_bi);
	printf("MYACLS::m_b2i = %d\n", &MYACLS::m_b2i);
	printf("MYACLS::m_i = %d\n", &MYACLS::m_i);
	printf("MYACLS::m_j = %d\n", &MYACLS::m_j);

	MYACLS myobj;
	myobj.m_i = 3;
	myobj.m_j = 6;
	myobj.m_bi = 9;
	myobj.m_b2i = 12;

	return 1;
}

运行结果：

解释：

（1）Base1和MYACLS共用的虚函数指针占4个字节，m_bi占4个字节;

         Base2的虚函数指针占4个字节，m_b2i占4个字节;

         m_i和m_j各占4各字节，所以总共24个字节

（2）m_bi的偏移量是相对于Base1的，m_b2i的偏移量是相对于Base2的，所以偏移量都为4

（3）m_i和m_j的偏移量是相对于MYACLS的

（4）首先继承Base1，所以子类对象中父类Base1子对象的this指针与子类对象的this指针相同，而父类Base2子对象的this指针需要跳过Base1

内存详情查看：

内存布局：

结论：

（1）通过this指针打印，我们看到访问Base1成员不用跳 ，访问Base2成员要this指针要偏移
（2）this指针，加上偏移值 就的能够访问对应的成员变量，比如m_b2i = 成员变量声明所在类的this指针+偏移值，即我们要访问一个类对象中的成员，成员的定位是通过：this指针（编译器会自动调整）以及该成员的偏移值，这两个因素来定位；这种this指针偏移的调整都需要编译器介入来处理完成；

2.this调整

代码2：

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

class Base1
{
public:
	int m_bi;
	virtual void mybvirfunc() {}

	Base1()
	{
		printf("Base1::Base1()的this指针是：%p!\n", this);
	}
};
class Base2
{
public:
	int m_b2i;
	virtual void mybvirfunc2() {}

	Base2()
	{
		printf("Base2::Base2()的this指针是：%p!\n", this);
	}
};
class MYACLS :public Base1, public Base2
{
public:
	int m_i;
	int m_j;

	virtual void myvirfunc() {} //虚函数
	MYACLS()
	{
		int abc = 1; 
		printf("MYACLS::MYACLS()的this指针是：%p!\n", this);
	}
	~MYACLS()
	{
		int def = 0;
	}
};

int main()
{

	MYACLS myobj;
	Base2 *pbase2 = &myobj;
	Base1 *pbase1 = &myobj;
	printf("&myobj= %p\n", &myobj);
	printf("pbase2= %p\n", pbase2);
	printf("pbase1= %p\n", pbase1);
	return 1;
}

运行结果：

可以发现这种赋值过程中编译器帮我们进行了this指针调整

	Base2 *pbase2 = &myobj; //this指针调整导致pbase2实际是向前走8个字节的内存位置的
	                            //myobj = 0x005BFB1C，经过本语句以后，pbase2 = 0x0x005BFB24
	//站在编译器视角，把上边这行语句进行了调整
	//Base2 *pbase2 = (Base2 *)(((char *)&myobj) + sizeof(Base1));
	Base1 *pbase1 = &myobj; //this指针调整之后还是和myobj的地址相同

代码3：

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

class Base1
{
public:
	int m_bi;
	virtual void mybvirfunc() {}

	Base1()
	{
		printf("Base1::Base1()的this指针是：%p!\n", this);
	}
};
class Base2
{
public:
	int m_b2i;
	virtual void mybvirfunc2() {}

	Base2()
	{
		printf("Base2::Base2()的this指针是：%p!\n", this);
	}
};
class MYACLS :public Base1, public Base2
{
public:
	int m_i;
	int m_j;

	virtual void myvirfunc() {} //虚函数
	MYACLS()
	{
		int abc = 1; 
		printf("MYACLS::MYACLS()的this指针是：%p!\n", this);
	}
	~MYACLS()
	{
		int def = 0;
	}
};


int main()
{
	Base2 *pbase2 = new MYACLS(); //父类指针new子类对象 ，这里new出来的是24字节
	MYACLS *psubobj = (MYACLS *)pbase2; //比上边地址少了8字节（偏移）
	printf("pbase2 = %p\n", pbase2);
	printf("psubobj = %p\n", psubobj);
	//delete pbase2; //报异常。所以我们认为pbase2里边返回的地址不是分配的首地址，而是偏移后地址。
	          //而真正分配的首地址应该是在psubobj里边的这个地址
	delete psubobj;

}

运行结果：

解释：

    Base2 *pbase2 = new MYACLS(); 
	MYACLS *psubobj = (MYACLS *)pbase2;
    //同理,这两句赋值过程中也是编译器自动帮我们进行了this指针的调整

另外结论：

访问父类成员跟访问子类成员的效率差不多，不管是通过 对象.成员 还是 对象->成员 的方式访问都差不多

3.更复杂的继承关系的数据布局

例如：

继承关系：

内存布局：