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

C++系列总结——new和delete

程序员文章站 2022-11-18 12:38:53
前言 " 和`malloc() new malloc() new new delete`。 选择性的含义是有构造函数就会执行,没有构造函数则不会执行。 new是什么 是C++的一个关键字,这个关键字有两种用法 " 运算符" :分配内存 " 表达式" :分配内存并初始化 通常我们都是使用 表达式,当然 ......

前言

"newmalloc()有什么区别",这是一个很常见的c++面试题。我的回答是"new等于malloc()后再选择性执行构造函数"。执行流程上是这样的,但是这样的回答是有纰漏的,比如没有考虑异常。下面就仔细聊一聊new,了解了new就了解了delete

选择性的含义是有构造函数就会执行,没有构造函数则不会执行。

new是什么

new是c++的一个关键字,这个关键字有两种用法

  • :分配内存
  • :分配内存并初始化

通常我们都是使用new表达式,当然我们也可以直接使用new运算符。

int* a = new int;  // new表达式
int* b = (int*)operator new( sizeof(int) );  // new运算符

new表达式

调试一下下面这段代码,看看编译器是如何对待new表达式的。

class a
{
public:
    a(){}
    ~a(){}
    int a;
};
int main()
{
    a* a = new a;
    return 0;
}

截取一段汇编代码

=> 0x000000000040061f <+9>:     mov    $0x4,%edi    # 0x4就是a的大小,作为参数值传递
   0x0000000000400624 <+14>:    callq  0x400510 <_znwm@plt>    # 单步调试,就会进入operator new( unsigned long ) 函数
   0x0000000000400629 <+19>:    mov    %rax,%rbx    # rax里存储了返回的内存地址
   0x000000000040062c <+22>:    mov    %rbx,%rdi    # 将分配的内存地址作为参数
   0x000000000040062f <+25>:    callq  0x400644 <a::a()>    # 如果没有构造函数的话,这里就不会调用了

从上,我们发现当使用new表达式时,编译器做的工作就是计算出类型的大小,然后将该大小作为参数调用operator new(),最后调用构造函数在operator new()返回的地址上做初始化。因为分配的大小是编译器自己计算出来的,所以即使operator new()的返回值是void*,编译器也不会告警。

new运算符

常用的new运算符原型有如下几种

1. void* operator new( std::size_t count ) throw( std::bad_alloc );    // 对应着 new t
2. void* operator new( std::size_t count, const std::nothrow_t& tag) throw(); // 对应着 new(std::nothrow) t
3. void* operator new( std::size_t count, void* ptr ) throw(); // 对应着 new(ptr) t,直接在ptr所指的内存上执行t的构造函数进行初始化。

1和2的区别仅在于1会抛出异常,而2不会。

一定不要写出类似下面的代码,当分配不出内存时,其实际结果是不符合预期的。

a* a = new a;
if( null == a ){
    return false;
}

除去异常这块,我们能看到new运算符和malloc()几乎是一模一样的:指定分配的内存大小,返回void*类型。如果去看内部实现的话,我们更会发现operator new()其实就是调用了malloc(),毕竟没有必要重复造*嘛。

new[]

new[]表达式和new表达式本质上没有什么差别,都是分配内存并初始化,只不过new[]表达式是一次性对分配多个对象的内存并初始化。

常用的new[]表达式,对应以下几种new[]运算符

1. void* operator new[]( std::size_t count ) throw( std::bad_alloc );    // 对应着 new t[n]
2. void* operator new[]( std::size_t count, const std::nothrow_t& tag) throw(); // 对应着 new(std::nothrow) t[n]
3. void* operator new[]( std::size_t count, void* ptr ) throw(); // 对应着 new(ptr) t[n],实际是直接返回ptr

调试代码可以发现new[]运算符实际就是调用了对应的new运算符。

为了讲解new[]表达式的一些实现,需要从delete[]开始说起。当我们写delete[] a;时,并没有像new[]那样指定元素个数,那么编译器如何知道需要执行几次析构函数呢?答案很简单,就是new[]的时候,编译器会多分配点空间用来保存元素个数。

为什么delete[]不指定元素个数?我想还是为了减少程序员的工作量。

让我们来看看代码

class a
{
public:
    a(){}
    ~a(){}
private:
    int a;
};
int main()
{
    a* a = new a[1];
}

从下面的汇编可以看出实际分配的大小是12个字节,a地址的前8个字节保存了元素个数

=> 0x0000000000400623 <+13>:    mov    $0xc,%edi    # count是12
   0x0000000000400628 <+18>:    callq  0x400500 <_znam@plt>    # 调用operator new[]()
   0x000000000040062d <+23>:    mov    %rax,%rbx    #  将operator new[]()的返回值,放入rbx
   0x0000000000400630 <+26>:    movq   $0x1,(%rbx)    # 记录元素个数是1
   0x0000000000400637 <+33>:    lea    0x8(%rbx),%rax    # 往后移动8字节,开始调用构造函数

delete[]会根据记录的元素个数执行完指定个数的析构函数,然后往前偏移8字节,调用free()释放内存。

我们知道编译器是不会做多余的事,如果没有析构函数需要执行的话,还需要多分配空间来保存元素个数么?答案是不需要!

class a
{
public:
    a(){}
private:
    int a;
};
int main()
{
    a* a = new a[1];
}

可以看到分配的大小就是4字节。

   0x0000000000400623 <+13>:    mov    $0x4,%edi                                                                     
   0x0000000000400628 <+18>:    callq  0x400500 <_znam@plt>   # 调用operator new[]()

因此如果没有析构处理的必要的话,就不要写析构函数了,省内存。

到这里,我们很自然的就能知道为什么newdelete以及new[]delete[]要配套使用了。

后话

newdelete是很基础的知识了,日常只需要记住配套使用,不遗漏delete就足够了。

可以想想,下面这段代码运行时会有问题么,会破坏malloc内存管理结构、内存泄漏或者踩内存么?

a* a = new a;

a->~a();
delete[] (char*)a;