菱形继承,多继承,虚继承、虚表的内存结构全面剖析（逆向分析基础）
// 声明：以下代码均在Win32_Sp3 VC6.0_DEBUG版中调试通过..
在逆向还原代码的时候，必须得掌握了菱形继承,多继承,虚继承虚函数的内存虚表结构。所以，这篇文章献给正在学习C++的朋友们。
当然，由于水平有限，必定错漏百出！所以，希望耽误您的时间，恳求您的指点。在这里万分感谢！
首先，我们定义如下类：
class A { public: A() { m_nData = 1; } virtual void fun() { } int m_nData; }; class B { public: B() { m_nData = 2; } virtual void fun() { } int m_nData; }; class AB :public A, public B { public: AB() { m_nData = 3; } virtual void fun() { } int m_nData; }; int main(int argc, char* argv[]) { AB the; return 0; }
类的构造顺序：先基类-->在成员对象-->在派生类(自己)
所以the对象的构造过程如下：
按照继承定义时写的顺序：
1、基类A构造：虚表赋值,成员数据
2、基类B构造：虚表赋值,成员数据
3、派生类AB构造：虚表覆盖,成员数据
内存中结构如下图：
在做如下修改：
class A { public: A() { m_nData = 1; } virtual void fun() { } virtual void fun1() // 新增加 { } int m_nData; }; class B { public: B() { m_nData = 2; } virtual void fun() { } virtual void fun2() // 新增加 { } int m_nData; }; class AB :public A, public B { public: AB() { m_nData = 3; } virtual void fun() { } virtual void fun3() // 新增加 { } int m_nData; }; int main(int argc, char* argv[]) { AB the; return 0; }
对于the对象来说，它的内存结构的内存结构还是不会改变，但是虚表的内容会改变，改变后的虚表如下：
1、A::Vtable如下：
&AB::fun &A::fun1 AB::fun3
2、B::Vtable如下:
&AB::fun &B::fun2
总结一下：先按继承声明顺序依次构造虚表，如果子类有虚函数，并且不同名，则填写到声明顺序首位的基类虚表中的末尾项。
我们从浅到深慢慢的剖析虚继承的内存结构，首先看源码如下：
class A { public: A() { m_nDataA = 1; } int m_nDataA; }; class B :virtual public A { public: B() { m_nDataB = 2; } int m_nDataB; }; int main(int argc, char* argv[]) { B the; return 0; }
假设没有virtual虚继承关键字，the对象在内存中的结构如下:
A::m_nDataA
B::m_nDataB
现在我们的源码中有virtual继承关键字，那么内存结构必然会有区别,那么内存结构是怎么样的呢？如下：
B::base Offset m_nDataA // A::m_nDataA数据的偏移
B::m_nDataB
A::m_nDataA
编译器为什么要这么做呢？这个偏移值是什么？这么做的意义又何在？
首先，这么做是为了只存在于一份虚基类数据。后面会讲解。
B::base Offset 偏移的值，一般为全局数据区中。编译器为了和虚表区别。这个指针指向的地址的值一般为：0x00000000, 或者某些特殊值
而在他后面的4个字节中。才是真正数据的偏移地址
为什么取这两个值？为什么不直接写偏移呢？
编译器为了在内存中只产生一份基类数据，当然就必须得写偏移值，可是又为了和虚表区分。所以只能取特殊值作为区分。(当然这里仅个人猜想，不作参考)
继续看源码：
class A { public: A() { m_nDataA = 1; } virtual void fun() { } int m_nDataA; }; class B :virtual public A { public: B() { m_nDataB = 2; } virtual void fun() { } int m_nDataB; }; int main(int argc, char* argv[]) { B the; return 0; }
现在多了虚表的加入。内存结构有了大的变化
the对象的内存结构如下：
B::base Offset A // B的父类A的偏移
B::m_nDataB
0x00000000 // 虚基类的非虚基类的分隔符
B::Virtual
A::m_nDataA
划红线的地方，产生覆盖，我们慢慢剖析编译器构造的过程。
the对象初始化空间如下：
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
先是虚基类的构造。内存结构如下：
1、第一步
B::base Offset A // 填入A类的偏移
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
2、第二步
B::base Offset A // 由此处指向内容向下4个字节为B的父类A的偏移。取出内容偏移地址后。当前地址 + 偏移地址 == 填写A类虚表的地址
0xCCCCCCCC
0xCCCCCCCC
A::virtual // A类的虚表
0xCCCCCCCC
3、第三步
B::base Offset A
0xCCCCCCCC
0xCCCCCCCC
A::virtual
A::m_nDataA
4、第四步(程序流程返回到派生类B构造函数)
B::base Offset A
0xCCCCCCCC
0x00000000 // 填充全0,作为虚基类和非基类的分隔符
A::virtual
A::m_nDataA
5、第五步(虚表赋值)
A::Offset A
0xCCCCCCCC
0x00000000
B::virtual // 由于派生类的有写fun虚函数。构成覆盖关系。所以覆盖A的虚表
A::m_nDataA
6、第六步
B::base Offset A
B::m_nDataB // B::m_nDataB
0x00000000
B::virtual
A::m_nDataA
我们继续看源码：
class A { public: A() { m_nDataA = 1; } virtual void fun() { } virtual void fun1() { } int m_nDataA; }; class B :virtual public A { public: B() { m_nDataB = 2; } virtual void fun() { } virtual void fun2() { } int m_nDataB; }; int main(int argc, char* argv[]) { B the; return 0; }
加入了虚函数，构成多个虚表的the对象内存结构如下：
B::Vtable
B::base Offset A
B::m_nDataB
0x00000000
A::Vtable
A::m_nDataA
我们继续慢慢剖析内存结构。the对象初始化内存空间如下：
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
0xCCCCCCCC
1、第一步
0xCCCCCCCC
B::base offset A // B的虚基类A的偏移地址. 规律找出来了。不用看偏移基本也可以推测出以下上个区域
0xCCCCCCCC
0xCCCCCCCC // 这里应该是虚基类和非虚基类的分隔符。
0xCCCCCCCC // 后面的步骤会填充为A的虚表
0xCCCCCCCC // 后面的步骤会填充为A的数据成员m_nDataA
结果会是我们推测的这样吗？这是构造完虚基类A的情况。
果然和我们猜想的一样.到这里了。你肯定会问。为什么不在是对象的首地址开始填充偏移地址了。
这里要搞清楚的是。现在派生类有了自己虚函数Fun2(). 并且和父类不同名。所以必须单独建立一张虚表了。于是编译器就这样安排内存结构了.
继续往下剖析：
由于重复的操作，省略...... 我们直接来看第五步
5、第五步(派生类B的构造函数)
B::virtual
B::base offset A
0xCCCCCCCC
0x00000000 // 虚基类和非虚基类的分隔符
A::Virtual
A::m_nDataA
这里红色标记的地方产生了派生类虚函数的覆盖，虚表中的结构如下：
B::fun // 覆盖掉了 A::fun
A::fun1
并且,产生一个B虚表,虚表中的结构如下：
B::fun2
6、第六步
B::virtual
B::base offset A
B::m_nDataB // B的成员数据
0x00000000
A::Virtual
A::m_nDataA
好了，现在有了前面的讲解,我们来剖析下较为复杂菱形继承的内存结构，源码如下：
class A { public: A() { m_nDataA = 1; } int m_nDataA; }; class B :virtual public A { public: B() { m_nDataB = 2; } int m_nDataB; }; class C :virtual public A { public: C() { m_nDatac = 3; } int m_nDatac; }; class BC :public B, public C { public: BC() { m_nDataBC = 4; } int m_nDataBC; }; int main(int argc, char* argv[]) { BC the; return 0; }
由于是虚继承,所以虚基类只会产生一份拷贝.内存结构必然如下：
B::base offset A
B::m_nDataB
C::base offset A
C::m_nDataC
BC::m_nDataBC
A::m_nDataA
在变形下.源码如下：
class A { public: A() { m_nDataA = 1; } int m_nDataA; virtual void fun(){} // 新增加 }; class B :virtual public A { public: B() { m_nDataB = 2; } int m_nDataB; virtual void fun(){} // 新增加 }; class C :virtual public A { public: C() { m_nDatac = 3; } int m_nDatac; virtual void fun(){} // 新增加 }; class BC :public B, public C { public: BC() { m_nDataBC = 4; } int m_nDataBC; virtual void fun(){} // 新增加 }; int main(int argc, char* argv[]) { BC the; return 0; }
加了虚函数后，the对象的内存结构如下：
B::base offset A
B::m_nDataB
C::base offset A
C::m_nDataC
0x00000000
BC::vtable
A::m_nDataA
红色地方同理，派生类的fun多次覆盖父类的。最后为BC::vtable。
我们继续变形如下：
class A { public: A() { m_nDataA = 1; } virtual void fun(){} virtual void funA(){} int m_nDataA; }; class B :virtual public A { public: B() { m_nDataB = 2; } virtual void fun(){} virtual void funB(){} int m_nDataB; }; class C :virtual public A { public: C() { m_nDatac = 3; } virtual void fun(){} virtual void funC(){} int m_nDatac; }; class BC :public B, public C { public: BC() { m_nDataBC = 4; } virtual void fun(){} virtual void funBC(){} int m_nDataBC; }; int main(int argc, char* argv[]) { BC the; return 0; }
the对象的内存结构如下：
B::vtable
B::base offset A
B::m_nDataB
C::vtable
C::base offset A
C::m_nDataC
BC::m_nDataBC
0x00000000
A::vtable
A::m_nDataA
B::vtable中表末尾存放着BC::funBC, 而BC::fun则覆盖到A::vtable中.
BC::funBC我们知道。即使不是虚继承。也会自动填充到按定义顺序首基类的虚表的末尾。
而B是定义的首继承基类,而B::fun中又覆盖掉了虚基类A的虚表的A::fun，由于B和C虚继承于A。
所以B和C不能同时都在虚基类A中虚表末尾加上各自的虚函数，所以只能自己建张表.
然而BC又是以B定义顺序的基类.也不是虚继承。就把BC::funBC直接填充到B::vtable末尾.
到此为止,我们分析了几乎大部分虚继承的内存结构。在看到内存的时候。大家是否能还原出代码呢？
当然了。还有很多更复杂的结构。只要掌握了最基本的原理。无非就是组合使用了！
