本文分析了栈对象和堆对象的构造和析构过程。

1. 测试环境

• Linux ubuntu18arm64 4.15.0-76-generic #86-Ubuntu SMP Fri Jan 17 17:25:58 UTC 2020 aarch64 aarch64 aarch64 GNU/Linux
• gcc version 7.4.0 (Ubuntu/Linaro 7.4.0-1ubuntu1~18.04.1)
• c++11

2. 调试分析

在本文的栈对象和堆对象示例中，我们统一使用如下class。

class Base {
 public:
  Base(int i) : m_var(i) {
  }

  ~Base() {
    m_var = 0;
  }

 private:
  int m_var;
};

2.1 栈对象

2.1.1 测试代码

void stack() {
  Base stack_obj(1);
}

stack()的反汇编如下

(gdb) disas
Dump of assembler code for function stack():
   0x0000aaaaaaaaae84 <+0>: stp x29, x30, [sp, #-32]!
   0x0000aaaaaaaaae88 <+4>: mov x29, sp
   0x0000aaaaaaaaae8c <+8>: adrp    x0, 0xaaaaaaabb000
   0x0000aaaaaaaaae90 <+12>:    ldr x0, [x0, #4024]
   0x0000aaaaaaaaae94 <+16>:    ldr x1, [x0]
   0x0000aaaaaaaaae98 <+20>:    str x1, [x29, #24]
   0x0000aaaaaaaaae9c <+24>:    mov x1, #0x0                    // #0
   0x0000aaaaaaaaaea0 <+28>:    add x0, x29, #0x10
   0x0000aaaaaaaaaea4 <+32>:    mov w1, #0x1                    // #1
   0x0000aaaaaaaaaea8 <+36>:    bl  0xaaaaaaaab098 <Base::Base(int)>
=> 0x0000aaaaaaaaaeac <+40>:    add x0, x29, #0x10
   0x0000aaaaaaaaaeb0 <+44>:    bl  0xaaaaaaaab0bc <Base::~Base()>
   0x0000aaaaaaaaaeb4 <+48>:    nop
   0x0000aaaaaaaaaeb8 <+52>:    adrp    x0, 0xaaaaaaabb000
   0x0000aaaaaaaaaebc <+56>:    ldr x0, [x0, #4024]
   0x0000aaaaaaaaaec0 <+60>:    ldr x1, [x29, #24]
   0x0000aaaaaaaaaec4 <+64>:    ldr x0, [x0]
   0x0000aaaaaaaaaec8 <+68>:    eor x0, x1, x0
   0x0000aaaaaaaaaecc <+72>:    cmp x0, #0x0
   0x0000aaaaaaaaaed0 <+76>:    b.eq    0xaaaaaaaaaed8 <stack()+84>  // b.none
   0x0000aaaaaaaaaed4 <+80>:    bl  0xaaaaaaaaacd0 <__stack_chk_fail@plt>
   0x0000aaaaaaaaaed8 <+84>:    ldp x29, x30, [sp], #32
   0x0000aaaaaaaaaedc <+88>:    ret
End of assembler dump.

2.1.2 构造

   0x0000aaaaaaaaadc0 <+28>:    add x0, x29, #0x10
   0x0000aaaaaaaaadc4 <+32>:    mov w1, #0x1                    // #1
   0x0000aaaaaaaaadc8 <+36>:    bl  0xaaaaaaaab008 <Base::Base(int)>

在本例里，栈对象的地址是x29 + 0x10, x29就是fp, 用于标识当前栈帧的起始地址，栈对象就位于fp偏移0x10的地方。

调用构造函数Base::Base(int)时，传入的参数如下

• 第1个参数是栈对象地址x0 = x29 + 0x10
• 第2个参数是w1 = 1

2.1.3 析构

对于栈对象，离开作用域前，将自动调用析构函数。

=> 0x0000aaaaaaaaadcc <+40>:    add x0, x29, #0x10
   0x0000aaaaaaaaadd0 <+44>:    bl  0xaaaaaaaab08c <Base::~Base()>

调用析构函数很简单，传入栈对象地址，直接调用Base::~Base()即可。

2.2 堆对象

2.2.1 测试代码

void heap() {
  Base *heap_obj = new Base(2);

  delete heap_obj;
}

heap()的反汇编如下

(gdb) disas
Dump of assembler code for function heap():
   0x0000aaaaaaaaaee0 <+0>: stp x29, x30, [sp, #-48]!
   0x0000aaaaaaaaaee4 <+4>: mov x29, sp
   0x0000aaaaaaaaaee8 <+8>: str x19, [sp, #16]
   0x0000aaaaaaaaaeec <+12>:    mov x0, #0x4                    // #4
   0x0000aaaaaaaaaef0 <+16>:    bl  0xaaaaaaaaad20 <_Znwm@plt>
   0x0000aaaaaaaaaef4 <+20>:    mov x19, x0
   0x0000aaaaaaaaaef8 <+24>:    mov w1, #0x2                    // #2
   0x0000aaaaaaaaaefc <+28>:    mov x0, x19
   0x0000aaaaaaaaaf00 <+32>:    bl  0xaaaaaaaab098 <Base::Base(int)>
=> 0x0000aaaaaaaaaf04 <+36>:    str x19, [x29, #40]
   0x0000aaaaaaaaaf08 <+40>:    ldr x19, [x29, #40]
   0x0000aaaaaaaaaf0c <+44>:    cmp x19, #0x0
   0x0000aaaaaaaaaf10 <+48>:    b.eq    0xaaaaaaaaaf24 <heap()+68>  // b.none
   0x0000aaaaaaaaaf14 <+52>:    mov x0, x19
   0x0000aaaaaaaaaf18 <+56>:    bl  0xaaaaaaaab0bc <Base::~Base()>
   0x0000aaaaaaaaaf1c <+60>:    mov x0, x19
   0x0000aaaaaaaaaf20 <+64>:    bl  0xaaaaaaaaad10 <_ZdlPv@plt>
   0x0000aaaaaaaaaf24 <+68>:    nop
   0x0000aaaaaaaaaf28 <+72>:    ldr x19, [sp, #16]
   0x0000aaaaaaaaaf2c <+76>:    ldp x29, x30, [sp], #48
   0x0000aaaaaaaaaf30 <+80>:    ret
End of assembler dump.

2.2.2 构造

对于堆对象，通过new运算符显式构造。

• 调用operator new分配内存
• 调用构造函数
• 返回堆对象指针

先看分配内存

   0x0000aaaaaaaaaeec <+12>:    mov x0, #0x4                    // #4
   0x0000aaaaaaaaaef0 <+16>:    bl  0xaaaaaaaaad20 <_Znwm@plt>
   0x0000aaaaaaaaaef4 <+20>:    mov x19, x0

Base类只有一个数据成员int m_var, 在编译期能获知其实例大小为4。 然后传给operator new函数去分配4字节大小的堆内存。若分配成功，则将堆内存地址保存到x19

operator new的实现

源文件: gcc/libstdc++-v3/libsupc++/new_op.cc

_GLIBCXX_WEAK_DEFINITION void *
operator new (std::size_t sz) _GLIBCXX_THROW (std::bad_alloc)
{
  void *p; 

  /* malloc (0) is unpredictable; avoid it.  */
  if (sz == 0)
    sz = 1;

  while (__builtin_expect ((p = malloc (sz)) == 0, false))
    {   
      new_handler handler = std::get_new_handler (); 
      if (! handler)
        _GLIBCXX_THROW_OR_ABORT(bad_alloc());
      handler (); 
    }   

  return p;
}

operator new实现如下

• 调用c库函数malloc()尝试分配内存。若分配成功， 则返回。
• malloc()分配失败后， 会先获取new handler(通过std::set_new_handler()设置)。若handler不为空，则调用handler，否则抛出bad_alloc异常。

  terminate called after throwing an instance of 'std::bad_alloc'
    what():  std::bad_alloc
  Aborted (core dumped)
  

注: 若在Base内将operator new重载为private, 则该类不能生成堆对象。

再看调用构造函数

   0x0000aaaaaaaaaef8 <+24>:    mov w1, #0x2                    // #2
   0x0000aaaaaaaaaefc <+28>:    mov x0, x19
   0x0000aaaaaaaaaf00 <+32>:    bl  0xaaaaaaaab098 <Base::Base(int)>

调用构造函数Base::Base(int)时，传入的参数如下

• 第1个参数是operator new返回的堆内存地址x0
• 第2个参数是w1 = 2

最后将堆对象指针存储到栈内

=> 0x0000aaaaaaaaaf04 <+36>:    str x19, [x29, #40]

2.2.3 析构

对于堆对象，通过delete运算符显式析构。

• 调用堆对象的析函数
• 调用operator delete释放内存

先看调用堆对象的析构函数

   0x0000aaaaaaaaaf08 <+40>:    ldr x19, [x29, #40]
   0x0000aaaaaaaaaf0c <+44>:    cmp x19, #0x0
   0x0000aaaaaaaaaf10 <+48>:    b.eq    0xaaaaaaaaaf24 <heap()+68>  // b.none
   0x0000aaaaaaaaaf14 <+52>:    mov x0, x19
   0x0000aaaaaaaaaf18 <+56>:    bl  0xaaaaaaaab0bc <Base::~Base()>

检查堆对象指针是否为空

• 若是，则跳过析构函数和operator delete 函数的调用(delete空指针没问题)
• 否则，调用析构函数

再看调用operator delete释放堆内存

   0x0000aaaaaaaaaf1c <+60>:    mov x0, x19
   0x0000aaaaaaaaaf20 <+64>:    bl  0xaaaaaaaaad10 <_ZdlPv@plt>

最后看下operator delete的实现

源文件: gcc/libstdc++-v3/libsupc++/del_op.cc

_GLIBCXX_WEAK_DEFINITION void
operator delete(void* ptr) _GLIBCXX_USE_NOEXCEPT
{
  std::free(ptr);
}

可以看到，operator delete直接调用了c库的free()函数

3. 总结

• 栈对象位于stack，定义栈对象时自动构造完成初始化，超出作用域后自动析构，开发人员不必刻意维护栈对象。
• 堆对象位于heap, 需要new/delete(间接调用malloc()/free())显式构造和析构，如果没有及时析构容易引起内存泄露，可借助智能指针加强堆对象的内存管理。

---

程序员自我修养(ID: dumphex)

---