从汇编看c++中默认构造函数的使用分析

int main() {
    X x;
}

    push    ebp;ebp为一个寄存器，总是指向一个函数调用堆栈的栈底，作为基址，用偏移量来访问该调用栈上的变量，但这里没有任何变量要访问，因此不起作用
    mov    ebp, esp;这两句的作用是为了保存调用main之前堆栈的基址ebp的值，并将ebp指向main调用栈的栈底
    push    ecx;将寄存器ecx的值压栈, 栈顶指针esp向前移动4byte
               ;这句的作用，为即将要创建的对象预留了4byte的空间，并向里面写入ecx的值

; 8    :     X x;
; 9    : }

    xor    eax, eax;eax也是一个寄存器，这里不起作用
    mov    esp, ebp;将栈顶指针移动到push ecx前的位置，即释放了4byte的空间
    pop    ebp;恢复基址到main调用之前的状态
    ret    0;函数返回

int main() {
    X x;
}

    push    ebp
    mov    ebp, esp
    sub    esp, 8; 栈顶指针移动8byte，刚好等于类X的大小

; 9    :     X x;
; 10   : }

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0

int main() {
    X x;
}

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 为对象x预留12byte的空间，成员变量int i，int j占8byte，由于有虚函数，因此vptr指针占4byte

; 14   :     X x;

    lea    ecx, DWORD PTR _x$[ebp];获取x对象的首地址，存入ecx寄存器
    call    ??0X@@QAE@XZ;这里调用x的构造函数

; 15   : }

    lea    ecx, DWORD PTR _x$[ebp];获取对象x的首地址
    call    ??1X@@UAE@XZ                ; 调用析构函数
    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0

class Y : public X{//Y继承自X
private:
    int i;
};

int main() {
    Y y;
}

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 为对象y预留12byte空间，y自身成员变量int i占4byte 父类中的成员变量int i int j占8byte

; 20   :     Y y;

    lea    ecx, DWORD PTR _y$[ebp];获取对象y的首地址，存入寄存器ecx
    call    ??0Y@@QAE@XZ;调用对象y的构造函数

; 21   : }

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0

    push    ebp
    mov    ebp, esp
    push    ecx
    mov    DWORD PTR _this$[ebp], ecx; ecx中存有对象y的首地址

; 8    :         i = 0;

    mov    eax, DWORD PTR _this$[ebp];对象y首地址给寄存器eax
    mov    DWORD PTR [eax], 0;初始化父类中的变量i

; 9    :         j = 1;

    mov    ecx, DWORD PTR _this$[ebp];对象y首地址给寄存器ecx
    mov    DWORD PTR [ecx+4], 1;初始化父类中的变量j,在对象y的内存空间中，从首地址开始的8比特用来存储继承自父对象的成员变量，后4byte用来存储自己的成员变量
                            ;由于首地址存储了父类成员变量i，因此内存地址要从对象y的首地址要移动4byte，才能找到父类成员变量j所处位置

; 10   :     }

    mov    eax, DWORD PTR _this$[ebp]
    mov    esp, ebp
    pop    ebp
    ret    0

   
};

class Y : public X{//Y继承自X
private:
    int i;
};

int main() {
    Y y;
}

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 和刚才一样，为对象y预留12byte

; 17   :     Y y;
; 18   : }

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 和刚才一样，为对象y预留12byte

; 17   :     Y y;
; 18   : }

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 为对象y预留12byte 成员对象的变量占8byte 对象y自身占变量占4byte 成员对象包含在对象y中

; 22   :     Y y;

    lea    ecx, DWORD PTR _y$[ebp];对象y的首地址存入ecx
    call    ??0Y@@QAE@XZ;调用对象y的构造函数，由编译器提供的默认构造函数

; 23   : }

    xor    eax, eax
    mov    esp, ebp

    pop    ebp
    ret    0

; 7    :     X() {

    push    ebp
    mov    ebp, esp
    push    ecx
    mov    DWORD PTR _this$[ebp], ecx;ecx中存有成员对象x的起始地址

; 8    :         i = 0;

    mov    eax, DWORD PTR _this$[ebp];成员对象x的起始地址给eax寄存器
    mov    DWORD PTR [eax], 0;初始化成员对象x中额成员变量i

; 9    :         j = 0;

    mov    ecx, DWORD PTR _this$[ebp];成员对象x的起始地址给ecx寄存器
    mov    DWORD PTR [ecx+4], 0;初始化成员对象x中额成员变量j 加4的原因是j的地址偏离了成员对象x起始地址4byte(即成员对象x的成员变量i的字节数)

; 10   :     }

    mov    eax, DWORD PTR _this$[ebp]
    mov    esp, ebp
    pop    ebp
    ret    0

   
};

class Y {
private:
    int i;
    X x;//x成员对象
};

int main() {
    Y y;
}

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 为对象预留12byte空间

; 18   :     Y y;
; 19   : }

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0