C++系列总结——构造与析构

前言

在使用资源前，我们需要做一些准备工作保证资源能正常使用，在使用完资源后，我们需要做一些扫尾工作保证资源没有泄露，这就是构造与析构了，这和编程语言是无关的，而是使用资源的一种方式。c++只不过是把这个过程内置到了语言本身，规定了构造函数和析构函数的形式以及执行时机。

编译器的无私奉献

下面这段代码很好理解

#include <iostream>
class a
{
public:
    a()
    {
        std::cout << "a\n";
    }
    ~a()
    {
        std::cout << "~a\n";
    }
};
int main()
{
    a local;
    return 0;
}

如果执行的话，会输出

a
~a

对于一个从c转到c++的人，我就很纠结为什么我没有调用a::a()和a::~a()，它们却执行了。

在gdb面前，程序是没有秘密的，因此就让我们开始gdb，看看剥去高级语言的外衣后的程序是什么样子。
用gdb的disassemble命令查看汇编代码，可以看到实际上调用了a::a()（callq 0x400888 <a::a()>）和a::~a()（callq 0x4008a6 <a::~a()>）。果然没有任何神奇的地方，函数都是需要被调用才会执行的，只不过我没有做的时候，编译器帮我做了。

(gdb) disassemble                                                                                                    
dump of assembler code for function main():                                                                          
   0x0000000000400806 <+0>:     push   %rbp                                                                          
   0x0000000000400807 <+1>:     mov    %rsp,%rbp                                                                     
   0x000000000040080a <+4>:     push   %rbx                                                                          
   0x000000000040080b <+5>:     sub    $0x18,%rsp                                                                    
=> 0x000000000040080f <+9>:     lea    -0x11(%rbp),%rax                                                              
   0x0000000000400813 <+13>:    mov    %rax,%rdi                                                                     
   0x0000000000400816 <+16>:    callq  0x400888 <a::a()>                                                             
   0x000000000040081b <+21>:    mov    $0x0,%ebx                                                                     
   0x0000000000400820 <+26>:    lea    -0x11(%rbp),%rax                                                              
   0x0000000000400824 <+30>:    mov    %rax,%rdi                                                                     
   0x0000000000400827 <+33>:    callq  0x4008a6 <a::~a()>                                                            
   0x000000000040082c <+38>:    mov    %ebx,%eax                                                                     
   0x000000000040082e <+40>:    add    $0x18,%rsp                                                                    
   0x0000000000400832 <+44>:    pop    %rbx                                                                          
   0x0000000000400833 <+45>:    pop    %rbp                                                                          
   0x0000000000400834 <+46>:    retq                                                                                 
end of assembler dump.

编译器除了帮我们调用构造函数和析构函数外，如果我们没有写构造函数和析构函数，编译器会帮我们补上默认的构造函数和析构函数吗？
在下面的情况下，编译器会帮我们补上默认的构造函数

• 类成员变量有构造函数：默认的构造函数里就是为了调用一下类成员变量的构造函数
• 类的父类有构造函数：默认的构造函数就是为了调用一下父类的构造函数。父类是否有默认构造函数，同样取决于上一种情况。
• 类的父类有虚函数：默认的构造函数就是为了设置一下虚函数表

在下面的情况下，编译器会帮我们补上默认的析构函数

• 类成员变量有自己的析构函数：默认的析构函数里就只是为了调用一下类成员变量的析构函数
• 类的父类有自己的析构函数：默认的析构函数为了调用父类的析构函数

从上面我们也可以看出编译器不做无用之事。当不需要构造函数或析构函数时，编译器就不会补上默认的构造函数和析构函数。我们知道c语言中是没有构造函数和析构函数的，可以简单的认为符合c语言语法的自定义类型，编译器都不会补上默认的构造函数和析构函数。大家可以了解下pod类型。

”符合c语言语法的自定义类型“的描述是不准确的，这是在将class视为struct，忽略权限关键字public、protected、private的基础上说的，毕竟c中没有这些关键字。

构造和析构的时机

下面描述的前提是存在构造函数和析构函数

当实例化对象时，会执行构造函数，而实例化对象分为两种情况

• 定义变量，如a a;。需要特别注意的是通过thread_local修饰定义的变量，在首次在线程中使用时才会执行构造函数。

• new实例化，如new a;

  构造函数是无法主动调用的

当对象存储期结束时，就会执行析构函数，存储期分为

• 静态存储期：进程退出时执行析构函数，如全局变量和静态局部变量
• 自动存储期：离开变量的作用域时执行析构函数，如普通局部变量
• 动态存储期：new实例化的对象，在delete时会执行析构函数。

• 线程存储期：线程退出时执行析构函数，如thread_local修饰的变量

  因为析构函数是可以主动调用的，所以delete也可以只释放内存而不调用析构函数。

构造和析构的顺序

顺序就一句话：先构造后析构。分两部分来理解

• 为什么需要先构造后析构

• 如何实现先构造后析构

  先构造意味着先定义，但这只在同一文件中生效，不同文件之间的全局变量构造顺序是不确定的。

为什么需要先构造后析构

原因很朴素：先构造的对象说明其可能会被后续的对象使用，因此为了程序运行安全，必须等到其使用者结束使用后，才能析构该对象即在那些之后构造的对象析构后才能析构。

先构造后析构也是保证我们安全使用资源的一个原则。假设我们把一个功能的初始化封装为init()，把功能的销毁封装为destroy()，一般destroy()中资源销毁的顺序是init()中资源申请的逆序。

基于以上，我们就能很容易的理解

• 为什么父类的构造函数先执行：因为本类的构造函数可能要用到父类的东西
• 为什么类成员变量的构造函数先执行：因为本类的构造函数内可能要用到类成员变量

如何实现先构造后析构

普通局部变量的先构造后析构，就是编译器按照定义顺序插入对应的构造函数，然后再逆序插入析构函数。

int main()
{
    a local_1;
    a local_2;
    return 0;
}

其汇编如下

0x000000000040088f <+9>:     lea    -0x12(%rbp),%rax
0x0000000000400893 <+13>:    mov    %rax,%rdi               # local_1的地址
0x0000000000400896 <+16>:    callq  0x40093c <a::a()>                    
0x000000000040089b <+21>:    lea    -0x11(%rbp),%rax                     
0x000000000040089f <+25>:    mov    %rax,%rdi                 # local_2的地址                            
0x00000000004008a2 <+28>:    callq  0x40093c <a::a()>                    
0x00000000004008a7 <+33>:    mov    $0x0,%ebx                            
0x00000000004008ac <+38>:    lea    -0x11(%rbp),%rax                     
0x00000000004008b0 <+42>:    mov    %rax,%rdi                 # local_2的地址
0x00000000004008bf <+57>:    callq  0x40095a <a::~a()>                   
0x00000000004008c4 <+62>:    mov    %ebx,%eax                            
0x00000000004008c6 <+64>:    jmp    0x4008e2 <main()+92>                 
0x00000000004008c8 <+66>:    mov    %rax,%rbx                            
0x00000000004008cb <+69>:    lea    -0x12(%rbp),%rax                     
0x00000000004008cf <+73>:    mov    %rax,%rdi                # local_1的地址  
0x00000000004008d2 <+76>:    callq  0x40095a <a::~a()>

全局变量和静态局部变量在析构函数的设置上稍有差别。

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

因为全局变量的构造在main()之前，所以在a::a()上设置断点。执行后，打印调用栈如下

(gdb) bt                                                                                                             
#0  a::a (this=0x601171 <gloabl>) at main.cpp:15                                                                     
#1  0x0000000000400856 in __static_initialization_and_destruction_0 (                                                
    __initialize_p=1, __priority=65535) at main.cpp:23                                                               
#2  0x0000000000400880 in _global__sub_i_gloabl () at main.cpp:27                                                    
#3  0x000000000040090d in __libc_csu_init ()                                                                         
#4  0x00007ffff771fe55 in __libc_start_main (main=0x400806 <main()>, argc=1,                                         
    argv=0x7fffffffec48, init=0x4008c0 <__libc_csu_init>,                                                            
    fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffec38)                                       
    at libc-start.c:246                                                                                              
#5  0x0000000000400739 in _start ()

让我们回到frame 1截取一小段它的汇编代码

   0x0000000000400851 <+64>:    callq  0x400882 <a::a()>                                                             
=> 0x0000000000400856 <+69>:    mov    $0x601058,%edx                                                                
   0x000000000040085b <+74>:    mov    $0x601171,%esi                                                                
   0x0000000000400860 <+79>:    mov    $0x4008a0,%edi                                                                
   0x0000000000400865 <+84>:    callq  0x4006d0 <__cxa_atexit@plt>

我们发现在执行完a::a()后，还调用了__cxa_atexit@plt。看到__cxa_atexit@plt，有没有觉得很熟悉，是不是立即就想到int atexit( void (*function)(void))。我们知道atexit()用于注册一个在进程退出时执行的函数，那么这里是不是注册了全局变量的析构函数？
mov $0x4008a0,%edi就是给`__cxa_atexit@plt传递参数，可知注册的函数地址是0x4008a0。我们可以轻易地发现a::~a()的地址就是0x4008a0。

类成员函数的第一个参数是this，mov $0x601171,%esi的0x601171就是变量global的地址。

由此我们知道全局变量的析构函数是在执行构造函数后，注册为进程退出时的执行函数。我们知道通过atexit()注册的函数的执行顺序是先注册的后执行即filo，__cxa_atexit也是一样，也就实现了先构造后析构。静态局部变量的析构函数也是一样的设置方式。

假设一个类继承自一个有构造函数的类，且其成员变量也拥有构造函数。我们知道会先执行父类和成员变量的构造函数，然后再执行本类的构造函数。按这样的描述，岂不是要在每个实例化该类的地方加上很多额外的代码了，编译器会这么蠢么？让我们来看一下

class a
{
public:
    a(){}
    ~a(){}
};
class b
{
public:
    b(){}
    ~b(){}
};
class c : public a
{
public:
    c(){ std::cout << "c\n" };
    ~c(){}
    b a;
};
int main()
{
    c local;
    return 0;
}

查看汇编，可知实际调用的仍是c::c()，并非在c::c()之前插入a和b的构造函数，

   0x00000000004006e6 <+16>:    callq  0x400788 <c::c()>                    
   0x00000000004006eb <+21>:    mov    $0x0,%ebx                            
   0x00000000004006f0 <+26>:    lea    -0x11(%rbp),%rax                     
   0x00000000004006f4 <+30>:    mov    %rax,%rdi                            
   0x00000000004006f7 <+33>:    callq  0x4007b0 <c::~c()>

而是在c::c()的第一行代码前，插入了a和b的构造函数。

dump of assembler code for function c::c(): 
   0x0000000000400788 <+0>:     push   %rbp                                 
=> 0x0000000000400789 <+1>:     mov    %rsp,%rbp                            
   0x000000000040078c <+4>:     sub    $0x10,%rsp                           
   0x0000000000400790 <+8>:     mov    %rdi,-0x8(%rbp)                      
   0x0000000000400794 <+12>:    mov    -0x8(%rbp),%rax                      
   0x0000000000400798 <+16>:    mov    %rax,%rdi                            
   0x000000000040079b <+19>:    callq  0x400758 <a::a()>                    
   0x00000000004007a0 <+24>:    mov    -0x8(%rbp),%rax                      
   0x00000000004007a4 <+28>:    mov    %rax,%rdi                            
   0x00000000004007a7 <+31>:    callq  0x400770 <b::b()>                    
   0x00000000004007ac <+36>:    nop                                         
   0x00000000004007ad <+37>:    leaveq                                      
   0x00000000004007ae <+38>:    retq

当然c::~c()的最后一行代码之后，也会插入a和b的析构函数。

常见问题

问题通常都来自于错误的构造顺序。
一种情况是a.cpp中定义的全局变量a使用了b.cpp中定义的全局变量b，实际a先构造，此时a使用到了还未构造的b，程序会出现异常。建议是保证不同全局变量之间是独立的。如果存在使用关系，则定义为指针类型，延迟到main()中再按预期的顺序依次实例化。

还有一种更常见的情况是使用了静态局部变量。因为静态局部变量包含在函数内部，更隐晦，所以更容易出现问题。问题通常是在进程退出时出现的，静态局部变量先析构了，导致程序异常。

后话

构造与析构是一种资源使用机制，我们常用c++的构造函数和析构函数来实现raii（resource acquisition is initialization），保证诸如锁、内存等资源的正确使用和释放。

以上的代码都在www.onlinegdb.com上运行调试的。不同平台，不同编译器，其底层实现会存在差异，高级语言本就是为了隐藏这些底层差异，因此不必纠结于具体实现，而是要关注思维方式。