欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-19 10:35:54
前言 在使用资源前,我们需要做一些准备工作保证资源能正常使用,在使用完资源后,我们需要做一些扫尾工作保证资源没有泄露,这就是构造与析构了,这和编程语言是无关的,而是使用资源的一种方式。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,忽略权限关键字publicprotectedprivate的基础上说的,毕竟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

类成员函数的第一个参数是thismov $0x601171,%esi0x601171就是变量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上运行调试的。不同平台,不同编译器,其底层实现会存在差异,高级语言本就是为了隐藏这些底层差异,因此不必纠结于具体实现,而是要关注思维方式。