C++与汇编小结

---

本文通过C++反编译，帮助理解C++中的一些概念（指针引用、this指针、虚函数、析构函数、lambda表达式），
希望能在深入理解C++其它一些高级特性（多重继承、RTTI、异常处理）能起到抛砖引玉的作用吧。

指针和引用

引用类型的存储方式和指针是一样的，都是使用内存空间存放地址值。
只是引用类型是通过编译器实现寻址，而指针需要手动寻址。

void funRef(int &ref){    ref++;}int main(){    //定义int类型变量    int var = 0x41;    //int指针变量，初始化为变量var的地址    int *pnVar = &var;    //取出指针pcVar指向的地址内容并显示    char *pcVar = (char*)&var;    printf("%s",pcVar);    //引用作为参数，即把var的地址作为参数    funRef(var);    return 0;}

用godbolt查看的效果如图，C++代码与对应的汇编代码用相同的颜色标注，非常方便查看。

---

switch

在分支数少的情况下可以用if–else if模拟，
但是分支比较大的情况下，需要比较的次数太多，
如果是有序线性的数值，可将每个case语句块的地址预先保存在数组中，
考察switch语句的参数，并依次查询case语句块地址的数组，
从而得到对应case语句块的首地址，
这样可以降低比较的次数，提升效率。

int main(){    int nIdx=1;    scanf("%d",&nIdx);    int result = 0;    switch(nIdx){        case 1:            result = 1;            break;        case 2:            result = 2;            break;          case 3:            result = 3;            break;        case 5:            result = 3;            break;          case 7:            result = 3;            break;          }    return result;}

如下图，编译器把switch跳转表放到了.L4所指向的区域，其中的元素.L2、.L3 … .L8指向case对应代码地址。

---

this指针

this指针中保存了所属对象的首地址。

在调用成员函数的过程中，编译器利用rdi寄存器保存了对象的首地址，
并以寄存器传参的方式传递到成员函数中。

#include <stdio.h>class Location{public:    Location(){        //this指针指向一块16字节的内存区域        m_x = 1;        //m_x是一个8字节类型，所以mov一个4字        //mov     DWORD PTR [rax], 1        m_y = 2;        //mov     WORD PTR [rax+4], 2    }    short getY(){        //获取this指针（对象首地址）偏移4处的数据，即m_y的值        //movzx   eax, WORD PTR [rbp-8+4]        return m_y;    }private:    int m_x; //占4字节    short m_y; //占2字节    //由于内存对齐，整个对象占8字节};int main(){    //在栈上分配16字节，其中有8字节分配给是loc    //把栈上loc的内存地址（即this指针）作为参数调用Location构造函数。    Location loc;    //把栈上loc的内存地址（即this指针）作为参数调用getY成员函数。    short y = loc.getY();    //y变量位于[rbp-2]处    //mov     WORD PTR [rbp-2], ax    return 0;}

对应的汇编如下：

虚函数和虚表

编译器会为每一个包含虚函数的类（或通过继承得到的子类）生成一个表，其中包含指向类中每一个虚函数的指针。
这样的表就叫做虚表（vtable）。
此外，每个包含虚函数的类都获得另外一个数据成员，用于在运行时指向适当的虚表。
这个成员通常叫做虚表指针（vtable pointer），并且是类中的第一个数据成员。

在运行时创建对象时，对象的虚表指针将设置为指向合适的虚表。
如果该对象调用一个虚函数，则通过在该对象的虚表中进行查询来选择正确的函数。

代码举例如下，详细代码在这里。

class BaseClass {public:   BaseClass(){x=1;y=2;};   virtual void vfunc1() = 0;   virtual void vfunc2(){};   virtual void vfunc3();   virtual void vfunc4(){};   void hello(){printf("hello，y=%d",this->y);};private:   int x;//4字节   int y;};class SubClass : public BaseClass {public:   SubClass(){z=3;};   virtual void vfunc1(){};   virtual void vfunc3();   virtual void vfunc5(){};private:   int z;};

虚表布局

下图是一个简化后的内存布局，它动态分配了一个SubClass类型的对象，编译器会确保该对象的第一个字段虚表指针指向正确的虚表。虚表指向编译器为每个类在只读段创建的一块区域，即虚表，类似于数组，其中的大部分元素指向在代码段中的成员函数地址。C++编译器会在编译阶段给这些函数名做name mangling，以实现c++中函数重载、namespace等标准。

vtable for SubClass:        .quad   0        .quad   typeinfo for SubClass ;RTTI相关        .quad   SubClass::vfunc1() ;this指针中的虚表指针一般指向这个偏移处        .quad   BaseClass::vfunc2()        .quad   SubClass::vfunc3()        .quad   BaseClass::vfunc4()        .quad   SubClass::vfunc5()vtable for BaseClass:        .quad   0        .quad   typeinfo for BaseClass ;RTTI相关        .quad   __cxa_pure_virtual ;vfunc1是纯虚函数        .quad   BaseClass::vfunc2()        .quad   BaseClass::vfunc3()        .quad   BaseClass::vfunc4()

SubClass 中包含两个指向属于BaseClass的函数（ BaseClass::vfunc2 和 BaseClass::vfunc4）的指针。
这是因为 SubClass 并没有重写这2个函数，而是直接继承自BaseClass 。
由于没有针对纯虚函数BaseClass::vfunc1的实现，因此，在 BaseClass的虚表中并没有存储 vfunc1 的地址。
这时，编译器会插入一个错误处理函数的地址，名为 purecall，万一被调用，它会令程序终止或者其他编译器想要发生的行为。
另外，一般的成员函数不在虚表里面，因为不涉及动态调用，如BaseClass中的hello()函数。

创建对象

这里已在堆上动态创建对象为例。
调用new操作符，在堆上动态分配一块SubClass大小的内存，rax指向这块内存的开始。
SubClass需要的内存大小为24字节=8(虚表指针)+4*3(3个int类型的成员变量)+4(内存对齐)
对象首地址的值作为参数调用SubClass构造函数。

   BaseClass *a_ptr = new SubClass();

main:        ;...        mov     edi, 24 ;SubClass需要24字节的内存        call    operator new(unsigned long)        mov     rbx, rax        mov     rdi, rbx ;this指针作为参数        call    SubClass::SubClass()

SubClass的构造函数，在完成自身的任务之前会调用基类的构造函数，然后对this指针的内存的虚表指针修改为指向SubClass自身的虚表。

SubClass::SubClass():        push    rbp        mov     rbp, rsp        sub     rsp, 16        mov     QWORD PTR [rbp-8], rdi        mov     rax, QWORD PTR [rbp-8]        mov     rdi, rax ;this指针        call    BaseClass::BaseClass()        mov     edx, OFFSET FLAT:vtable for SubClass+16 ;指向SubClass虚表        mov     rax, QWORD PTR [rbp-8]        mov     QWORD PTR [rax], rdx ;this指针的虚表指针字段赋值        mov     rax, QWORD PTR [rbp-8]        mov     DWORD PTR [rax+16], 3 ;z=3        nop        leave        ret

BaseClass的构造函数:

BaseClass::BaseClass():        push    rbp        mov     rbp, rsp        mov     QWORD PTR [rbp-8], rdi ;this指针        mov     edx, OFFSET FLAT:vtable for BaseClass+16 ;指向BaseClass虚表        mov     rax, QWORD PTR [rbp-8]        mov     QWORD PTR [rax], rdx ;this指针的虚表指针字段赋值        mov     rax, QWORD PTR [rbp-8]        mov     DWORD PTR [rax+8], 1 ;x=1        mov     rax, QWORD PTR [rbp-8]        mov     DWORD PTR [rax+12], 2 ;y=2        nop        pop     rbp        ret

调用成员函数

1、非虚函数

hello()是类BaseClass中的非虚成员函数，不需要通过虚表查找，编译器直接生成调用语句call BaseClass::hello()，并且第一个参数默认为this指针。

    BaseClass *a_ptr = new SubClass();   //一般的成员函数，不在虚表里   a_ptr->hello();

main:        ;...                mov     rdi, rax ;参数:this指针        call    BaseClass::hello().LC0:        .string "hello\357\274\214y=%d"BaseClass::hello():        push    rbp        mov     rbp, rsp        sub     rsp, 16        mov     QWORD PTR [rbp-8], rdi  ;this指针放到栈上        mov     rax, QWORD PTR [rbp-8]        mov     eax, DWORD PTR [rax+12] ;this指针偏移12处，即成员变量y的位置        mov     esi, eax              ;参数:format的数据，即y的值        mov     edi, OFFSET FLAT:.LC0 ;参数:format string        mov     eax, 0                ;参数:fd，指向stdout        call    printf        nop        leave        ret

2、虚函数

a_ptr是BaseClass类型的指针，动态分配的是SubClass类型的内存。
call_vfunc函数的参数是基类BaseClass，再调用vfunc3函数时需要先根据虚表指针定位到虚表，再通过偏移，解引用找到vfunc3的代码段地址，完成调用。

int main(){    BaseClass *a_ptr = new SubClass();    //对象首地址作为参数调用函数call_vfunc   call_vfunc(a_ptr);}void call_vfunc(BaseClass *a) {   a->vfunc3();}  

main:    ;...        mov     rax, QWORD PTR [rbp-24]    mov     rdi, rax ;rax为this指针    call    call_vfunc(BaseClass*)call_vfunc(BaseClass*):        push    rbp        mov     rbp, rsp        sub     rsp, 16        mov     QWORD PTR [rbp-8], rdi ;把this指针放到栈上        mov     rax, QWORD PTR [rbp-8]        mov     rax, QWORD PTR [rax]   ;this指向的内存的开头8个字节的数据复制给rax,即虚表指针        add     rax, 16                ;找到虚表指针偏移16        mov     rax, QWORD PTR [rax]   ;虚表指针偏移16处解引用，得到函数的SubClass::vfunc3的地址        mov     rdx, QWORD PTR [rbp-8]        mov     rdi, rdx              ;rdi为this指针，作为参数        call    rax                   ;调用vfunc3        nop        leave        ret   

---

析构函数

这里以堆分配的对象析构为例，完整代码在这里。
堆分配的对象的析构函数在分配给对象的内存释放之前通过 delete 操作符调用。
其过程如下：
1、如果类拥有任何虚函数，则还原对象的虚表指针，使其指向相关类的虚表。如果一个子类在创建过程中覆盖了虚表指针，就需要这样做。
2、执行程序员为析构函数指定的代码。
3、如果类拥有本身就是对象的数据成员，则执行这些成员的析构函数。
4、如果对象拥有一个超类，则调用超类的析构函数
5、如果是释放堆的对象，则用一个代理析构函数执行1~4步骤，并在最后调用delete操作符释放堆上的对象。

class BaseClass {public:   BaseClass(){x=1;y=2;};   virtual ~BaseClass(){printf("~BaseClass()\n");};   virtual void vfunc1() = 0;private:   int x;//4字节   int y;};class SubClass : public BaseClass {public:   SubClass(){z=3;};   virtual ~SubClass(){printf("~SubClass()\n");};   virtual void vfunc1(){};private:   int z;};int main() {   BaseClass *a_ptr = new SubClass();   //触发析构    delete a_ptr; } 

;只读段中的虚表结构vtable for SubClass:    .quad   0    .quad   typeinfo for SubClass    .quad   SubClass::'scalar deleting destructor' ;代理析构函数的地址    .quad   SubClass::~SubClass() ;析构函数的地址，这里godbolt没有把它们区分出来    .quad   SubClass::vfunc1()main:     mov     QWORD PTR [rbp-24], rbx  ;rbx为a_ptr的指针     cmp     QWORD PTR [rbp-24], 0    ;判断a_ptr是否为null，这是编译器加的。     je      .L9                      ;如果为null直接跳过析构     mov     rax, QWORD PTR [rbp-24]     mov     rax, QWORD PTR [rax]     add     rax, 8                   ;this指针偏移8处，即指向代理析构函数     mov     rax, QWORD PTR [rax]     ;rax为代理析构函数的地址     mov     rdx, QWORD PTR [rbp-24]      mov     rdi, rdx                 ;参数：this指针     call    rax                      ;调用代理析构函数;SubClass的代理析构函数SubClass::'scalar deleting destructor':        push    rbp        mov     rbp, rsp        sub     rsp, 16        mov     QWORD PTR [rbp-8], rdi        mov     rax, QWORD PTR [rbp-8]        mov     rdi, rax              ;参数:this指针        call    SubClass::~SubClass() ;调用析构函数        mov     rax, QWORD PTR [rbp-8]        mov     esi, 24               ;参数:释放24字节大小的堆空间        mov     rdi, rax              ;参数:堆空间的首地址        call    operator delete(void*, unsigned long) ;释放堆空间        leave        ret .LC1:        .string "~SubClass()"       ;SubClass的析构函数，执行析构函数中的代码SubClass::~SubClass():    push    rbp    mov     rbp, rsp    sub     rsp, 16    mov     QWORD PTR [rbp-8], rdi    mov     edx, OFFSET FLAT:vtable for SubClass+16    mov     rax, QWORD PTR [rbp-8]    mov     QWORD PTR [rax], rdx      ;还原对象的虚表指针，使其指向相关类的虚表    mov     edi, OFFSET FLAT:.LC1    call    puts                      ;调用puts函数，这里编译器把printf调用转换成puts了。    mov     rax, QWORD PTR [rbp-8]    mov     rdi, rax                  ;参数：this指针     call    BaseClass::~BaseClass()   ;调用基类的析构函数    nop    leave    ret.LC0:        .string "~BaseClass()";BaseClass的析构函数，执行析构函数中的代码        BaseClass::~BaseClass():        push    rbp        mov     rbp, rsp        sub     rsp, 16        mov     QWORD PTR [rbp-8], rdi        mov     edx, OFFSET FLAT:vtable for BaseClass+16        mov     rax, QWORD PTR [rbp-8]        mov     QWORD PTR [rax], rdx        mov     edi, OFFSET FLAT:.LC0        call    puts        nop        leave        ret

通过分析C++析构函数的调用过程，我们就知道了为什么C++基类的析构函数要声明为virtual了。我们希望当调用C++基类BaseClass的析构函数时能够触发动态绑定，能够找到当前对象所属类的虚函数表中的析构函数。
如果不声明BaseClass的析构函数为virtual，那么在调用delete a_ptr时，将只会释放BaseClass大小的内存，给SubClass中成员变量分配的内存将得不到释放，从而导致内存泄漏。

C++11中的Lambda表达式

lambda表达式表示一个可调用的代码单元。可以理解为一个未命名的内联函数。
lambda表达式具有如下形式：

[capture list](parameter list) -> return type {function body}

下面定义了一个C++函数，其中有一个lambda表达式。v1之前的&符号指出v1是以引用方式捕获，当lambda返回v1时，它返回的是v1指向对象的值，所以j的值是0，而不是42.

void fcn1(){    int v1 =42;    auto f= [&v1] {return v1;};    v1 = 0;    auto j = f();}

对应的反汇编代码如下，可以看到编译器为fcn1中的lambda表达式在代码段中生成了一段指令，当调用这个lambda时就会执行到这段指令，跟普通的函数调用一致。
可以看出传递给fcn1()::{lambda()#1}函数的参数rdi的值其实就是v1变量的地址，所以这个lambda是是采用引用方式捕获变量的。

.Ltext0:fcn1()::{lambda()#1}::operator()() const:        push    rbp        mov     rbp, rsp        mov     QWORD PTR [rbp-8], rdi        mov     rax, QWORD PTR [rbp-8]        mov     rax, QWORD PTR [rax]        mov     eax, DWORD PTR [rax]        pop     rbp        retfcn1():        push    rbp        mov     rbp, rsp        sub     rsp, 16        mov     DWORD PTR [rbp-8], 42        lea     rax, [rbp-8]        mov     QWORD PTR [rbp-16], rax        mov     DWORD PTR [rbp-8], 0        lea     rax, [rbp-16]        mov     rdi, rax        call    fcn1()::{lambda()#1}::operator()() const        mov     DWORD PTR [rbp-4], eax        nop        leave        ret

---

参考

《IDA Pro权威指南》
《C++反汇编与逆向分析技术揭秘》
《C++ Primer（第5版）》