new和delete或new[]和delete[]为什么要配对使用？

内容源自《C++ Primer》第五版，以及程序喵大人wx公众号。

链接：https://mp.weixin.qq.com/s/_PNhbRj0Lt-kXHSXwUvvuQ

1.new和delete工作机理

​ 当我们使用一条new表达式时：

//new表达式
string *sp = new string("a value");//分配并初始化一个string对象
string *arr = new string[10]; //分配10个默认初始化的string对象

实际执行了三步操作。第一步，new表达式调用一个名为operator new（或者operator new[]）的标准库函数。该函数分配一块足够大的、原始的、未命名的内存空间以便存储特定类型的对象（或者对象的数组）。第二步，编译器运行相应的构造函数以构造这些对象，并为其传入初始值。第三步，对象被分配了内存空间并完成构造，返回以一个指向该对象的指针。

​ 当我们使用一条delete表达式删除一个动态分配的对象时：

delete sp; //销毁*sp，然后释放sp所指向的内存空间
delete []arry; //销毁数组中的元素，然后释放对应的内存空间

实际上执行了两步操作。第一步，对sp所指的对象或者arr所指数组中的元素执行相应的析构函数。第二步，编译器调用名为operator delete（或者operator delete[]）的标准库函数释放内存空间。

2.配对使用

​ 在C++中，new关键字在堆内存中创建对象，new[]用于在堆内存上创建对象数组。在书上或者技术博客上面

经常看到new和delete，new[]和delete[]一定要配对使用。然而有时我们自己编程过程中，不配对使用有时也不会出现问题。那这究竟是怎么一回事？接下来就在下面这段代码之中见真章吧。

​

#include<iostream>
using namespace std;

class Test{
public:
    Test(){cout<<"Constructing"<<endl;}
    ~Test(){cout<<"Destructing"<<endl;}
};
int main(){
    Test *p = new Test();
    Test *arr = new Test[2];

    delete p;
    delete []arr;
    system("pause");
    return 0;
}

程序输出：

image.png

new[]会创建一个数组，一个对象数组需要一定的空间大小，假设一个对象需要N字节大小，k个对象的数组就需要k*N的空间来构造对象数组，但是在delete[]的时候，如何知道要删除的数组的长度呢？

所以new[]会在k*N的内存空间基础之上，在头部会多申请4个字节，用于存储数组长度，这样delete[]释放内存空间的时候才知道要释放的对象数组的大小，才会相应调用k次析构函数，并且释放k*N+4的内存大小。

以上是配对使用的情况，接下来是不配对使用的状况。

3.不配对使用

3.1 new[]和delete结对使用

#include <stdlib.h>
#include <iostream>
using namespace std;
class inner {
   public:
    inner() { cout << "Constructing" << endl; }
    ~inner() { cout << "Destructing" << endl; }
};

int main(int argc, char *argv[]) {
    inner *p = new inner[2];
    delete p;
    return 0;
}

程序输出：
Constructing
Constructing
Destructing
munmap_chunk(): invalid pointer
Aborted (core dumped)

这里发现：程序挂掉了。

并且，只调用了一次析构函数，为什么呢？

因为我们使用了delete，delete不同于delete[]，它认为这只是一个对象占用的空间，不是对象数组，不会访问前4个字节获取长度，所以只调用了一次析构函数。而且，最后释放内存的时候只释放了起始地址为A的内存。然而这不是这一整块内存的起始地址，整块内存的起始地址应该是A-4，释放内存如果不从内存起始地址操作就会出现断错误，所以导致程序挂掉。

3.2 new和delete[]结对使用

#include <stdlib.h>
#include <iostream>
using namespace std;
class inner {
   public:
    inner() { cout << "Constructing" << endl; }
    ~inner() { cout << "Destructing" << endl; }
};

int main(int argc, char *argv[]) {
    inner *p = new inner();
    delete []p;
    return 0;
}
程序输出：
Constructing
Destructing
Destructing
Destructing
Destructing
Destructing
Destructing
...
Destructing
free(): invalid pointer
Aborted (core dumped)

这里调用了不定次数的析构函数，并且挂掉，是因为在new时候没有多申请4个字节存储长度，而delete[]时候还会向前找4个字节获取长度，这4个字节是未定义的，所以调用了不固定次数的析构函数，释放内存的时候也释放了起始地址为A-4的内存，而正常的起始地址应该是A，所以程序挂掉。

4.不配对使用的情况

我们再来看一段代码：

#include <stdlib.h>
#include <iostream>
using namespace std;

int main() {
    int *pint = new int(5);
    delete[] pint;
    int *pinta = new int[4];
    delete pinta;
    cout << "success" << endl;
    return 0;
}
程序输出：
success

这段代码即使不配对使用也会正常运行，这是为什么呢，因为int是内置类型，new[]和delete[]在配合int使用时知道int是内置类型，不需要析构函数，所以也就不需要多4个字节来存放数组长度，只需要直接操作内存即可。

5.总结

当类型为int, float等内置类型时，new、delete、new[]、delete[]不需要配对使用；当是自定义类型时，new、delete和new[]、delete[]才需要配对使用。当然，我们平时编程过程中，为了保证代码的可读性，以及养成良好的编程习惯，最好确保所有情况都配对使用。