Visual C++ 里的 Classes, Methods and RTTI

类的基本布局

为了说明以下内容，让我们考虑这个简单的例子：

class A

    {

      int a1;

    public:

      virtual int A_virt1();

      virtual int A_virt2();

      static void A_static1();

      void A_simple1();

    };

    class B

    {

      int b1;

      int b2;

    public:

      virtual int B_virt1();

      virtual int B_virt2();

    };

    class C: public A, public B

    {

      int c1;

    public:

      virtual int A_virt2();

      virtual int B_virt2();

    };

在大多数情况下，MSVC按以下顺序排列类：

指向虚拟函数表（vtable或vftable）的指针，仅当类具有虚拟方法且基类中没有合适的表可重用时添加
基类
类成员

虚拟函数表由虚拟方法的地址按其第一次出现的顺序组成。重载函数的地址替换基类中函数的地址。因此，我们三个类的布局如下所示：

class A size(8):

        +---

     0  | {vfptr}

     4  | a1

        +---

    A's vftable:

     0  | &A::A_virt1

     4  | &A::A_virt2

    class B size(12):

        +---

     0  | {vfptr}

     4  | b1

     8  | b2

        +---

    B's vftable:

     0  | &B::B_virt1

     4  | &B::B_virt2

    class C size(24):

        +---

        | +--- (base class A)

     0  | | {vfptr}

     4  | | a1

        | +---

        | +--- (base class B)

     8  | | {vfptr}

    12  | | b1

    16  | | b2

        | +---

    20  | c1

        +---

    C's vftable for A:

     0  | &A::A_virt1

     4  | &C::A_virt2

    C's vftable for B:

     0  | &B::B_virt1

     4  | &C::B_virt2

上面的图表是由VC8编译器使用未记录的开关生成的。若要查看编译器生成的类布局，请使用-d1reportSingleClassLayout查看单个类的布局-d1reportAllClassLayout查看所有类（包括内部CRT类）的布局，这些布局将转储到stdout。如您所见，C有两个vftable，因为它继承了两个类，这两个类都已经有了虚拟函数。A的地址替换C的vftable中A：：A的地址，C：：B的地址替换另一个表中B：：B的地址。

调用约定和类方法

默认情况下，MSVC中的所有类方法都使用thiscall约定。类实例地址（this指针）在ecx寄存器中作为隐藏参数传递。在方法体中，编译器通常会立即将其放入其他寄存器（如esi或edi）和/或堆栈变量中。类成员的所有进一步寻址都是通过该寄存器和/或变量完成的。但是，在实现COM类时，使用了“stdcall”约定。下面是各种类方法类型的概述。

Static Methods
静态方法不需要类实例，因此它们的工作方式与公共函数相同。不，这个指针被传递给他们。因此，不可能可靠地区分静态方法和简单函数。例子：
```
A::A_static1();

call    A::A_static1
```
简单方法
简单方法需要一个类实例，因此这个指针作为一个隐藏的第一个参数传递给它们，通常使用thiscall约定，即在ecx寄存器中。如果基对象不在派生类的开头，则需要调整此指针，使其在调用函数之前指向基子对象的实际开头。例子：
```
;pC->A_simple1();

    ;esi = pC

    push

    mov ecx, esi

    call    A::A_simple1

    ;pC->B_simple1(,);

    ;esi = pC

    lea edi, [esi+] ;adjust this

    push

    push

    mov ecx, edi

    call    B::B_simple1
```
如您所见，在调用B的方法之前，会将this指针调整为指向B子对象。

虚方法

要调用虚拟方法，编译器首先需要从vftable中获取函数地址，然后以与简单方法相同的方式调用该地址的函数（即将此指针作为隐式参数传递）。例子：

   ;pC->A_virt2()

    ;esi = pC

    mov eax, [esi]  ;fetch virtual table pointer

    mov ecx, esi

    call [eax+]  ;call second virtual method

    ;pC->B_virt1()

    ;edi = pC

    lea edi, [esi+] ;adjust this pointer

    mov eax, [edi]   ;fetch virtual table pointer

    mov ecx, edi

    call [eax]       ;call first virtual method

构造函数和析构函数
构造函数和析构函数的工作方式类似于一个简单的方法：它们得到一个隐式的this指针作为第一个参数（例如，在thiscall约定的情况下是ecx）。构造函数返回eax中的this指针，即使它在形式上没有返回值。

RTTI实现

RTTI（运行时类型标识）是一种特殊的编译器生成信息，用于支持C++类操作符，如dynamic_cast<> 和 typeid()，也适用于C++异常。由于RTTI的性质，它只需要（并生成）多态类，即具有虚拟函数的类。

MSVC编译器在vftable前面放置一个指向名为“Complete Object Locator”的结构的指针。之所以调用这个结构，是因为它允许编译器从一个特定的vftable指针中找到完整对象的位置（因为一个类可以有几个指针）。COL如下所示：

struct RTTICompleteObjectLocator

{

    DWORD signature; //always zero ?

    DWORD offset;    //offset of this vtable in the complete class

    DWORD cdOffset;  //constructor displacement offset

    struct TypeDescriptor* pTypeDescriptor; //TypeDescriptor of the complete class

    struct RTTIClassHierarchyDescriptor* pClassDescriptor; //describes inheritance hierarchy

};

分类描述描述描述分类的Inheritance Hierarchy。这是所有Cols for a class共享的。

struct RTTIClassHierarchyDescriptor

{

    DWORD signature;      //always zero?

    DWORD attributes;     //bit 0 set = multiple inheritance, bit 1 set = virtual inheritance

    DWORD numBaseClasses; //number of classes in pBaseClassArray

    struct RTTIBaseClassArray* pBaseClassArray;

};

基类数组描述所有基类以及允许编译器在执行“ _dynamic_cast_ operator”转换运算符期间将派生类转换为其中任何一个的信息。每个条目（基类描述符）具有以下结构：

struct RTTIBaseClassDescriptor

{

    struct TypeDescriptor* pTypeDescriptor; //type descriptor of the class

    DWORD numContainedBases; //number of nested classes following in the Base Class Array

    struct PMD where;        //pointer-to-member displacement info

    DWORD attributes;        //flags, usually 0

};

struct PMD

{

    int mdisp;  //member displacement

    int pdisp;  //vbtable displacement

    int vdisp;  //displacement inside vbtable

};

PMD结构描述基类是如何放置在完整类中的。在简单继承的情况下，它位于距对象开头的固定偏移处，该值是“_mdisp_ ”字段。如果它是虚拟基，则需要从vbtable获取额外的偏移量。用于调整从派生类到基类的指针的伪代码如下所示：

 //char* pThis; struct PMD pmd;

    pThis+=pmd.mdisp;

    if (pmd.pdisp!=-)

    {

      char *vbtable = pThis+pmd.pdisp;

      pThis += *(int*)(vbtable+pmd.vdisp);

    }

例如，我们三个类的RTTI层次结构如下所示：

更多信息

RTTI

如果有，RTTI是一个有价值的信息来源，可以用来逆转。从RTTI可以恢复类名、继承层次结构，在某些情况下还可以恢复类布局的某些部分。我的RTTI扫描仪脚本显示了大部分信息。（见附录一）

静态和全局初始值器

全局和静态对象需要在主程序启动之前初始化。MSVC通过生成初始化函数并将它们的地址放在表中来实现这一点，该表在CRT启动期间由cinit函数处理。表通常位于.data节的开头。典型的初始值设定项如下所示：

    _init_gA1:

        mov     ecx, offset _gA1

        call    A::A()

        push    offset _term_gA1

        call    _atexit

        pop     ecx

        retn

    _term_gA1:

        mov     ecx, offset _gA1

        call    A::~A()

        retn

因此，从这个表中我们可以发现：

全局/静态对象地址
构造器
析构器

另请参见MSVC _#pragma_ directive _init_seg_ [5]

展开函数

如果在函数中创建了任何自动对象，则VC++编译器自动生成异常处理结构，以确保在发生异常时删除这些对象。

unwind_1tobase:  ; state 1 -> -1

lea     ecx, [ebp+a1]

jmp     A::~A()

通过在函数体中找到相反的状态更改，或者只找到对同一堆栈变量的第一次访问，我们还可以找到构造函数

    lea     ecx, [ebp+a1]

    call    A::A()

    mov     [ebp+__$EHRec$.state],

对于使用new（）运算符构造的对象，展开函数确保在构造函数失败时删除已分配的内存：

unwind_0tobase: ; state 0 -> -1

        mov     eax, [ebp+pA1]

        push    eax

        call    operator delete(void *)

        pop     ecx

        retn

在函数体中：

;A* pA1 = new A();

        push

        call    operator new(uint)

        add     esp,

        mov     [ebp+pA1], eax

        test    eax, eax

        mov     [ebp+__$EHRec$.state], ; state 0: memory allocated but object is not yet constructed

        jz      short @@new_failed

        mov     ecx, eax

        call    A::A()

        mov     esi, eax

        jmp     short @@constructed_ok

    @@new_failed:

        xor     esi, esi

    @@constructed_ok:

        mov     [esp+14h+__$EHRec$.state], -

     ;state -1: either object was constructed successfully or memory allocation failed

     ;in both cases further memory management is done by the programmer

另一种类型的展开函数用于构造函数和析构函数。它确保在发生异常时销毁类成员。在这种情况下，函数使用保存在堆栈变量中的this指针：

unwind_2to1:

        mov     ecx, [ebp+_this] ; state 2 -> 1

        add     ecx, 4Ch

        jmp     B1::~B1

在这里，functlet在偏移量4Ch处销毁B1类型的类成员。因此，从展开functlet可以发现：

表示C++对象的堆栈变量，或指向用“ _operator new_”分配的对象的指针。
析构器
构造器
如果是新的物体，它们的大小

构造函数/析构函数递归

这个规则很简单：构造函数调用其他构造函数（基类和成员变量的构造函数），析构函数调用其他析构函数。典型的构造函数执行以下操作：

调用基类的构造函数。
调用复杂类成员的构造函数。
如果类具有虚拟函数，则初始化vfptr
执行程序员编写的构造函数体。

典型的析构函数几乎以相反的顺序工作：

如果类具有虚拟函数，则初始化vfptr
执行程序员编写的析构函数体。
调用复杂类成员的析构函数
调用基类的析构函数

MSVC生成的析构函数的另一个显著特点是，它们的状态变量通常以最大值初始化，然后与每个被析构函数化的子对象一起递减，这使得它们的识别更容易。请注意，简单的构造函数/析构函数通常由MSVC内联。这就是为什么您经常可以看到vftable指针在同一个函数中用不同的指针重复加载。

对象数组的构造/析构

MSVC编译器使用helper函数来构造和销毁对象数组。请考虑以下代码：

    A* pA = new A[n];

    delete [] pA;

它被转换为以下伪代码：

array = new char(sizeof(A)*n+sizeof(int))

    if (array)

    {

      *(int*)array=n; //store array size in the beginning

      'eh vector constructor iterator'(array+sizeof(int),sizeof(A),count,&A::A,&A::~A);

    }

    pA = array;

    'eh vector destructor iterator'(pA,sizeof(A),count,&A::~A);

如果有vftable，则在删除数组时将调用“vector deleting destructor'析构函数”：

   ;pA->'vector deleting destructor'();

    mov ecx, pA

    push  ; flags: 0x2=deleting an array, 0x1=free the memory

    call A::'vector deleting destructor'

如果A的析构函数是虚拟的，则它实际上被调用：

mov ecx, pA

push

mov eax, [ecx] ;fetch vtable pointer

call [eax]     ;call deleting destructor

因此，通过向量构造函数/析构函数迭代器调用，我们可以确定：

对象数组的地址
构造器
毁灭者
类size

删除析构函数

当类具有虚拟析构函数时，编译器生成一个帮助函数-删除析构函数。其目的是确保在销毁类时调用正确的delete运算符。删除析构函数的伪代码如下所示：

virtual void * A::'scalar deleting destructor'(uint flags)

    {

      this->~A();

      if (flags&) A::operator delete(this);

    };

这个函数的地址放在vftable中，而不是析构函数的地址中。这样，如果另一个类重写虚拟析构函数，将调用该类的运算符delete。尽管在实际代码中，delete运算符很少被重写，所以通常会看到对default delete（）的调用。有时编译器还可以生成向量删除析构函数。它的代码如下：

virtual void * A::'vector deleting destructor'(uint flags)

    {

      if (flags&) //destructing a vector

      {

        array = ((int*)this)-; //array size is stored just before the this pointer

        count = array[];

        'eh vector destructor iterator'(this,sizeof(A),count,A::~A);

        if (flags&) A::operator delete(array);

      }

      else {

        this->~A();

        if (flags&) A::operator delete(this);

      }

    };

巴特西