C++类对象内存模型与成员函数调用分析（下）

2.4.2 多重继承下的虚拟函数




多重继承下的虚拟函数主要有一下几个麻烦：
1. 几个父类都声明了相同原型的virtual函数；
2. 有不止一个父类将其析构函数声明为虚拟；
3. 一般的虚拟函数问题；
先给出代码段9。
class Parent1{
public:
Parent1() : data_parent1(0.0){}
virtual ~Parent1(){cout<<"Parent1::~Parent1()"<<endl;}
virtual void speakClearly(){cout<<"Parent1::speakClearly()"<<endl;}
virtual Parent1* clone() const{cout<<"Parent1::clone()"<<endl; return null;}
protected:
int data_parent1;
};

class Parent2{
public:
Parent2() : data_parent2(1.0){}
virtual ~Parent2(){cout<<"Parent2::~Parent2()"<<endl;}
virtual void mumble(){cout<<"Parent2::mumble()"<<endl;}
virtual Parent2* clone() const{cout<<"Parent2::clone()"<<endl; return null;}
protected:
int data_parent2;
};

class Child : public Parent1, public Parent2
{
public:
Child() : data_child(2.0){}
virtual ~Child(){cout<<"Child::~Child()"<<endl;}
virtual Child* clone() const{cout<<"Child::clone()"<<endl; return null;}
protected:
int data_child;
};
就内存布局而言，有了前面的基础了，猜得出来大概是个什么样子了。好吧，我们就先猜一把，然后再写段代码验证验证。对于数据成员，多重继承使用的就是各自分配一段空间“叠放”在一起，如之前的图4所示。对于虚拟函数，其实就是多了个vptr嘛，也放进去不久结了吗？
嗯，所以我们可以猜想了，见图8。



接下来就是调试验证了，调试代码段10如下：
typedef void(*Fun)(void);

int main()
{
Child c;
Fun pFun;

int** pVtbl = (int**)&c;

cout << "[0] Parent1::_vptr->" << endl;
pFun = (Fun)pVtbl[0][0];
cout << " [0] ";
pFun();

pFun = (Fun)pVtbl[0][1];
cout << " [1] ";
pFun();

cout << " Parent1.data_parent1 = " << (int)pVtbl[1] << endl;

int s = sizeof(Parent1)/4;
cout << "[" << s << "] Parent2::_vptr->"<<endl;
pFun = (Fun)pVtbl[s][0];
cout << " [0] "; pFun();

pFun = (Fun)pVtbl[s][1];
cout << " [1] "; pFun();

s++;
cout << " Parent2.data_parent2 = " << (int)pVtbl[s] << endl;

s++;
cout << "[3] Child.data_child = " << (int)pVtbl[s] << endl;
}
需要的是，这段代码的运行要将虚析构函数注释掉，理由应该很好理解吧，对象都被析构掉了，指针也就成为悬挂指针了，SIGSEGV就会触发。Code::Blocks(GCC 4.5.2)下运行结果如下：



再次说明一下，因为我们注释掉了虚析构函数那一行，所以上面的输出中没有Child::~Child()之类的信息。所以，我们的猜想图8是正确的。
根据《Inside The C++ Object Model》一书，关于多重继承主要有三种情况要仔细考虑，对着图8，这三种情况其实都是浮云。
1. 通过一个“指向第二个父类，如Parent2”的指针，调用子类的虚拟函数。请看代码段11：
Parent2* pP2 = new Child;
// 下面的代码将调用Child::~Child()
// 因此pP2必须被向后调整sizeof(Parent1)个bytes,由编译器和运行期信息参与完成
delete pP2;
还是回到图8，注意到一个问题，Parent1和Child指针所指向的位置是一样的(如果都是取的同一个Child对象的地址)，但是Parent2不是，它与Parent1和Child的指针之间存在一个偏移量，看下面的代码就知道了：
Child c;
Parent1* pP1 = &c;
Parent2* pP2 = &c;
Child* pC = &c;
cout<<pP1<<"/n"<<pC<<"/n"<<pP2<<"/n/n";
运行结果如下图：



pP1与pC内容一样，pP2与pP1和pC之间存在8个字节的偏移量（8个字节是由一个4字节int变量和一个4字节指针引起的）。
对于代码段11，因为pP2指向Child对象中Parent2子对象处，为了能够正确执行，pP2必须调整到Child对象起始处。
1. 通过一个“指向Child类”的指针，调用Parent2中一个继承而来的虚拟函数。在这种情况下，子类指针必须再次被调整，以指向第二个父类Parent2处。例如：
Child* pC = new Child;
// 调用Parent2::mumble()
// pC必须被向前调整sizeof(Parent1)个bytes,由编译器和运行期信息参与完成
pC->mumble();
2. 第三种情况发生在一个语言扩充性质之下：允许一个虚拟函数的返回值类型有所变化（注意，返回值类型不是激活C++重载机制的充分条件），可能是父类类型，也可能是子类类型，这一点通过clone()函数来描述，看下面代码：
Parent2* pP1 = new Child;
// 调用Child* Child::clone()
// 返回值必须被调整，以指向Parent2子对象,由编译器和运行期信息参与完成
Parent2* pP2 = pP1->clone();
当进行pP1->clone()时，pP1会被调整到指向Child对象的起始地址，于是clone的Child版会被调用，它会传回一个指针，指向一个新的Child对象，该对象的地址在被指定给pP2之前，必须经过调整，以指向Parent2子对象处。
之前的注释中都有一句话，“XXX必须被调整，以指向Parent2子对象,由编译器和运行期信息参与完成”，确实，就是编译器会去做的事情，我们也不用管，因为这也是compiler-dependent的。
2.4.3 虚继承下的虚拟函数
虚拟继承的出现就是为了解决重复继承中多个间接父类的问题的，经典继承结构图就是环形继承链:
class PP {……};
class P1 : virtual public PP{……};
class P2: virtual public PP{……};
class C : public P1, public P2{…… };
虚拟继承是个有点麻烦乃至无聊的东西，实践中不被推荐，一般来说：
1) 先是P1，然后是P2，接着是C，而PP这个超类都放在最后的位置；
2) 各个类内部的布局与多重继承一样；
3、C++对象模型总结
大道至简，如果理解了前面的文字，下面四句话应该就差不多了：
l 非静态数据成员都存放在对象所跨有的地址空间中，静态数据成员则存放于对象所跨有的地址空间之外；
l 非虚拟成员函数（静态和非静态）也存放于对象所跨有的地址空间之外，且编译器将其改写为普通的非成员函数的形式（以求降低调用开销）；
l 对于虚拟成员函数，则借助vtbl和vptr支持。
l 对于继承关系，子类对象跨有的地址空间中包含了父类对象的实体，通过嵌入type-info信息进行识别和虚函数调用。
4、参考资料
[1] Inside The C++ Object Model，Lippaman，第1、2、4章。
[2] C++对象内存布局，陈皓专栏， http://blog.csdn.net/haoel/archive/2008/10/15/3081328.aspx