深刻理解C++ new/delete, new []/delete[]动态内存管理

在C语言中，咱们写程序时，老是会有动态开辟内存的需求，每到这个时候咱们就会想到用malloc/free 去从堆里面动态申请出来一段内存给咱们用。但对这一块申请出来的内存，每每还须要咱们对它进行稍许的“加工”后即初始化 才能为咱们所用，虽然C语言为咱们提供了calloc来开辟一段初始化好（0）的一段内存，但面对象中各是各样的数据成员初始化，它一样一筹莫展。同时，为了保持良好的编程习惯，咱们也都应该对申请出来的内存做手动进行初始化。

对此，这经常让咱们感到一丝繁琐，因而到了C++中就有了new/delete, new []/delete[] 。用它们即可实现动态的内存管理。

 

new/delete, new []/delete [] 基本格式

---

 new/delete动态管理对象，new[]/delete[]动态管理对象数组。

 

 在C++中，把int 、char..等内置类型的变量也看做对象，它们也是存在构造函数和析构函数的，只是一般对它们，系统调用了默认的构造函数来初始化以及默认的析构（编译器优化）。因此new int、new int(3)看起来和普通的定义好像没什么区别。 但对于自定义类型的对象，此种方式在建立对象的同时，还会将对象初始化好；因而new/delete、new []/delete []方式管理内存相对于malloc/free的方式管理的优点就体现出来了，由于它们能保证对象一被建立出来便被初始化，出了做用域便被自动清理。

 

 

malloc/free和new/delete的区别和联系

---

　  

　　*  malloc/free只是动态分配内存空间/释放空间。而new/delete除了分配空间还会调用构造函数和析构函数进行初始化与清理（清理成员）。

　　*  它们都是动态管理内存的入口。
　　*  malloc/free是C/C++标准库的函数，new/delete是C++操做符。
　　*  malloc/free须要手动计算类型大小且返回值w为void*，new/delete可自动计算类型的大小，返回对应类型的指针。

　　*  malloc/free管理内存失败会返回0，new/delete等的方式管理内存失败会抛出异常。

 

尽管看起来new、new[] 和malloc 都能开得空间出来，而且以new 、new[]的方式好像还更有优点。但从系统层面看来，真正开出空间来的仍是malloc。为何这么说呢？

在C++ Primer书中有提到说： new/delete的表达式与标准库函数同名了，因此系统并无重载new或delete表达式。new/delete真正的实现实际上是依赖下面这几个内存管理接口的。c++中称之为“placement版”内存管理接口

接口原型：

void * operator new (size_t size);　　 void operator delete (size_t size); void * operator new [](size_t size);　　 void operator delete[] (size_t size);

 

探究它，不妨从这样一个类AA开始

 1 class AA
 2 {
 3 public:
 4     AA(size_t count = 1)
 5     {
 6         _a = new int[count];
 7         cout<<"AA()"<<endl;
 8     }
 9     
10     ~AA()
11     {
12         delete[] _a;
13         cout<<"~AA()"<<endl;
14     }
15 
16 private:
17     int* _a;
18 };

类AA

用AA* pA = new AA[10]建立对象,VS下经过调试进入new表达式内部系统函数,获得下面两个图：

   和

 

 

 经过上面两个图，大体能够看出来new表达式并不直接开辟内存出来，而是经过调用operator new来得到的内存，而operator new得到的内存实质上仍是用malloc开辟出来的。这便证明了前面所述的：开空间出来仍是得 malloc来。

一样的道理，delete表达式也不是直接去释放掉内存。好比对上面的对象数组进行delete

AA* pA = new AA[10];
delete[] pa;

 

delete[]实际作了这样几件事情：

　　*　依次调用pA指向对象数组中每一个对象的析构函数，共10次

　　*　调用operator delete[]()，它将再调用operator delete

　　*　底层用free执行operator delete表达式，依次释放内存

 

 综合相关资料，小结一下operator new/ operator delete：

 　　1.operator new/operator delete operator new[]/operator delete[] 和 malloc/free用法同样。
 　　2. 他们只负责分配空间/释放空间，不会调用对象构造函数/析构函数来初始化/清理对象。
　　 3. 实际operator new和operator delete只是malloc和free的一层封装

 

若是仔细看过上面的图，可能会有疑惑：new最后将开辟好内存用指针p返回，pA接收它。可为何p 和pA 会差上4字节？

这实际上是由于编译器用相差的这4个字节用来保存一个东西——对象个数，即AA* p = new AA[10] 中的‘10’。这也就不难解释 为何在delete[] 的时候，不用传给它对象个数。

                              

delete[] 删除时，将new[] 返回的地址再往前移4个字节即可以拿到要析构的对象个数了。

可是注意：new type[] ,只有type显示定义析构函数时，编译器才会多开4字节来保存对象个数。因此像new int、char这样的内置类型编译器不会多开这4字节，编译器自行优化。

它们之间可用下面的图展现：

 

 

new/delete, new []/delete[], malloc/free配套使用！

---

 

咱们new 出来多少个对象，就得调用多少次析构来对它们进行清理。在用new/delete,new[]/delete[], malloc/free进行内存的管理时，必定不能将它们搞混淆，使用它们必定记得配套使用。

 来看几个例子，仍是之前面AA类为例

 1 class AA
 2 {
 3 public:
 4     AA(size_t count = 1)
 5     {
 6         _a = new int[count];
 7         cout<<"AA()"<<endl;
 8     }
 9     
10     ~AA()
11     {
12         delete[] _a;
13         cout<<"~AA()"<<endl;
14     }
15 
16 private:
17     int* _a;
18 };

类AA

1.malloc/delete的组合

void Test1()
{

    AA* p1 = (AA*)malloc(sizeof(AA));   //没有报错，但不建议采用，容易引发混淆
    delete p1;                       
    AA* p2 = (AA*)malloc(sizeof(AA));   //报错，同上，释放位置也不对
    delete[] p2;
}

2.delete, delete[] 之间误用（值得注意）

void Test2()
{
    AA* p3 = new AA;         //不报错，但未清理干净。p3的构造函数开辟的空间没有被释放
    free(p3);
    AA* p4 = new AA[10];   //崩溃卡死，存在问题，释放位置被后移了4字节。同时只调用了一次析构函数
　　 delete p4; ，
　　 AA* p5 = new AA;     //报错 非法访问内存
　　 delete[] p5; 
}

 ①delete p4错误在于释放位置不对（和编译器实现new []的机制有关），致使内存泄漏

  

②delete[] p5 直接就崩了，此次new AA的时候并未多开4字节保存对象个数，编译器便没法知道要调用多少次析构函数（这里仅仅调用一次析构函数就行了）但编译器内部仍是试图去访问p5前4字节的内存，以此得到对象个数;这便非法内存访问了，因此程序就挂了。

 

3.针对内置类型

void Test3()
{
    int* p6 = new int[10];  //没问题
    delete[] p6;
    int* p7 = new int[10];  //没问题
    delete p7;
    int* p8 = new int[10];  //没问题
    free(p8);
           
}

 

内存管理内置类型，它们的析构函数其实上是可调可不调的，因此它的实现机制不像前面的new []/delete[]，编译器会自行对处理的数据作记录，而后处理;因此即使是不匹配的使用，它们也没出现什么问题。不只仅这种内置类型如此，那种无自定义类型析构函数的类对象，这样的用法一样不会表现出什么问题。但即使如此，为保存良好的编程习惯，仍是要配对地使用它们!

  结合前面new/delete 的实现机制，便不难分析得出它们若未配对使用可能出现的状况。

 

 

总的来讲，记住一点便可：new/delete、new[]/delete[] 配套使用老是没错的！