C++小黄鸭课堂（5）默认构造函数，教科书的惊天大骗局

还记得这段代码吗？

class A {
};

int main() {
    A a;
    return 0;
}

这里我们说到编译器会帮我们自动生成一个默认的构造函数，但是我们把它编译成汇编：

g++ -S test.cpp -o test.s

发现：

_main:                                  ## @main
    .cfi_startproc
## %bb.0:
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    xorl    %eax, %eax
    movl    $0, -4(%rbp)
    popq    %rbp
    retq
    .cfi_endproc
                                        ## -- End function

main函数里面并没有看到有函数调用。且看起来main函数似乎是直接return 0。
那么把代码修改一下再编译成汇编看一下：

int main() {
    return 0;
}

汇编：

_main:                                  ## @main
    .cfi_startproc
## %bb.0:
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    xorl    %eax, %eax
    movl    $0, -4(%rbp)
    popq    %rbp
    retq
    .cfi_endproc
                                        ## -- End function

What?这不就是跟我没修改前的代码编译出来的汇编一摸一样吗？难道是编译器觉得我这里的A a；语句没有任何作用，所以帮我屏蔽了，然后导致A的默认构造函数没有执行？

那么为了防止编译器使坏，我们来一个复杂点的例子：

class A {
    public:
    int i;
};

void test(A a) {
    cout << a.i << endl;
}

int main() {
    A a;
    test(a);
    return 0;
}

我给A加了一个成员变量i，且在main函数里面将实例化后的a对象传给了test函数，且在test函数里面打印了a.i的值。这编译器总不能偷懒不给我执行A的默认构造函数了把。

     1      .globl  _main                   ## -- Begin function main
     2      .p2align    4, 0x90
     3  _main:                                  ## @main
     4      .cfi_startproc
     5  ## %bb.0:
     6      pushq   %rbp
     7      .cfi_def_cfa_offset 16
     8      .cfi_offset %rbp, -16
     9      movq    %rsp, %rbp
    10      .cfi_def_cfa_register %rbp
    11      subq    $16, %rsp
    12      movl    $0, -4(%rbp)
    13      movl    -8(%rbp), %eax
    14      movl    %eax, -16(%rbp)
    15      movl    -16(%rbp), %edi
    16      callq   __Z4test1A
    17      xorl    %eax, %eax
    18      addq    $16, %rsp
    19      popq    %rbp
    20      retq
    21      .cfi_endproc
    22                                          ## -- End function

结果编译出来的汇编代码也只有call了test函数，并没有看到call默认构造函数。

那么我们来人工的把默认构造函数加上：

class A {
    public:
    A() {} // 加上默认构造函数
    int i;
};

void test(A a) {
    cout << a.i << endl;
}

int main() {
    A a;
    test(a);
    return 0;
}

最终的汇编结果：

     1      .globl  _main                   ## -- Begin function main
     2      .p2align    4, 0x90
     3  _main:                                  ## @main
     4      .cfi_startproc
     5  ## %bb.0:
     6      pushq   %rbp
     7      .cfi_def_cfa_offset 16
     8      .cfi_offset %rbp, -16
     9      movq    %rsp, %rbp
    10      .cfi_def_cfa_register %rbp
    11      subq    $16, %rsp
    12      movl    $0, -4(%rbp)
    13      leaq    -8(%rbp), %rdi  // 新
    14      callq   __ZN1AC1Ev      // 新
    15      movl    -8(%rbp), %eax
    16      movl    %eax, -16(%rbp)
    17      movl    -16(%rbp), %edi
    18      callq   __Z4test1A
    19      xorl    %eax, %eax
    20      addq    $16, %rsp
    21      popq    %rbp
    22      retq
    23      .cfi_endproc
    24                                          ## -- End function

这时会发现，main函数什么都没有变，仅仅是把我们以为编译器会帮我们自动生成的默认构造函数加上去，结果编译出来的汇编代码出现了变化。（13、14行）
此时会发现除了call我们的test函数之外，还会call一个不知名的函数（这大概率就是我们刚刚加上去的无参构造函数了）。
看到这里的小伙伴还觉得编译器会自动生成默认构造函数吗？