继承

这几天写的程序应用到多继承。

以前对多继承的概念非常清晰，可是很久没用就有点模糊了。

重新研究一下，“刷新”下记忆。

假设我们有下面的代码：
#include <stdio.h>
class A
{
private:
char data;
public:
A(){data = A;}
virtual void Show(){printf("A ");};
virtual void DispA(){printf("a ");};
};
class B
{
private:
int data;
public:
B(){data = B;}
virtual void Show(){printf("B ");};
virtual void DispB(){printf("b ");};
};
class C
{
private:
char data;
public:
C(){data = C;}
virtual void Show(){printf("C ");};
virtual void DispC(){printf("c ");}; };
class D : public A, public B, public C {
public:
char data;
public:
D(){data = D;}
virtual void Show(){printf("D ");};
virtual void DispD(){printf("d ");}; };
class E : public D
{
private:
char data;
public:
E(){data = E;}
virtual void Show(){printf("E ");};
virtual void DispE(){printf("e ");}; };
int main()
{
D *d = new D;
A *a = (A*)d;
B *b = (B*)d;
C *c = (C*)d;;
d->Show();
a->Show();
b->Show();
a->DispA();
b->DispB();
d->DispD();
D *d1 = (D*)a;
d1->Show();
d1->DispD();
D *d2 = (D*)b;
d2->Show();
d2->DispD();
char x = d->data;
return 0;
}
每个类都有两个虚拟函数Show()和DispX()。

类A,B,C是基本类，而D是多继承，最后E 又继承了D。

那么对于类E，它的内存映像是怎样的呢？为了解答这个问题，我们回顾一下基本类的内存映像：
+ --------------+ <- this
+ VTAB +
+ --------------+
+ +
+ Data +
+ +
+ --------------+
如果一个类有虚拟函数，那么它就有虚函数表（VTAB）。

类的第一个单元是一个指针，指向这个虚函数表。

如果类没有虚函数，并且它的祖先（所有父类）均没有虚函数，那么它的内存映像和C的结构一样。

所谓虚函数表就是一个数组，每个单元指向一个虚函数地址。

如果类Y是类X的一个继承，那么类Y的内存映像如下：
+ --------------+ <- this
+ Y 的VTAB +
+ --------------+
+ +
+ X 的Data +
+ +
+ --------------+
+ +
+ Y 的Data +
+ +
+ --------------+
Y的虚函数表基本和X的相似。

如果Y有新的虚函数，那么就在VTAB的末尾加上一个。

如果Y重新定义了原有的虚函数，那么原的指针指向新的函数入口。

这样无论是内存印象和虚函数表，Y都和X兼容。

这样当执行X* x = (Y*)y；之后,x可以很好的被运用，并且可以享受新的虚拟函数。

现在看多重继承:
class D : public A, public B, public C
{
....
}
它的内存映像如下:
+ --+ -----------------+ 00H <- this
+ + D 的VTAB +
+ A + -----------------+ 04H
+ + A 的数据+
+ --+ -----------------+ 08H
+ + B 的VTAB +
+ B + -----------------+ 0CH
+ + B 的数据+
+ --+ -----------------+ 10H
+ + C 的VTAB +
+ C + -----------------+ 14H
+ + C 的数据+
+ --+ -----------------+ 18H
+ D + D 的数据+
+ --+ -----------------+
（因为对齐于双字，A~D的数据虽然只是一个char，但需要对齐到DWORD，所以占4字节）
对于A,它和单继承没有什么两样。

B和C被简单地放在A的后面。

如果它们虚函数在D中被重新定义过（比如Show函数），那么它们需要使用新的VTAB，使被重定义的虚函数指到正确的位置上（这对于COM或类似的技术是至关重要的）。

最后，D的数据被放置到最后面。

对于E的内存映像问题就可以不说自明了。

下面我们看一下C++是如何处理
D *d;
......
B *b = (B*)d;
这样的要求的。

设置断点，进入反汇编，你可以看到如下的汇编代码：（因为UBB关系，将方括号替换成了大括号。

看上去有点别扭）
B *b = (B*)d;
00401062 cmp dword ptr {d},0
00401066 je main+73h (401073h)
00401068 mov eax,dword ptr {d}
0040106B add eax,8
0040106E mov dword ptr {ebp-38h},eax
00401071 jmp main+7Ah (40107Ah)
00401073 mov dword ptr {ebp-38h},0
0040107A mov ecx,dword ptr {ebp-38h}
0040107D mov dword ptr {b},ecx
从上述汇编代码可以看出：如果源（这里是d）是NULL，那么目标(这里是b)也将被置为NULL，否则目标将指向源的地址并向下偏移8个字节，正好就是上图所示B的VTAB位置。

至于为什么要用ebp-38h作缓存，这是编译器的算法问题了。

等以后有时间再研究。

接下来看一个比较古怪的问题，这个也是我写这篇文章的初衷:
根据上面的多继承定义，如果给出一个类B的实例b，我们是否可以求出D的实例?
为什么要问这个问题。

因为存在下面的可能性：
class B
{
...
virtual int GetTypeID()=0;
...
};
class D : public A, public B, public C
{
...
virtual int GetTypeID(){return 0;}; ...
};
class Z : public X, public Y, public B {
...
virtual int GetTypeID(){return 1;}; ...
};
void MyFunc(B* b)
{
int t = b->GetTypeID();
switch(t)
{
case 0:
DoSomething((D*)b); //可能吗？
break;
case 1:
DoSomething((Z*)b); //可能吗？
break;
default:
break;
}
}
猛一看很值得怀疑。

但仔细想想，这是可能的，事实也证明了这一点。

因为编译器了解这D 和B这两个类相互之间的关系（也就是偏移量），因此它会做相应的转换。

同样，设置断点，查看汇编：
D *d2 = (D*)b;
00419992 cmp dword ptr {b},0
00419996 je main+196h (4199A6h)
00419998 mov eax,dword ptr {b}
0041999B sub eax,8
0041999E mov &nb。