C++—动态内存管理之深入探究new和delete

C++中程序存储空间除栈空间和静态区外，每个程序还拥有一个内存池，这部分内存被称为或堆（heap）。程序可以用堆来存储动态分配的对象，即那些在程序运行时创建的对象。动态对象的生存期由程序来控制，当动态对象不再使用时，程序必须显式的销毁它们。new操作符就是从自由存储区上为对象动态分配内存空间的。这里的自由存储区可以是堆，或者静态区。

1、new和delete的使用

C++中通过一对运算符new和delete来完成动态内存分配。new，在动态内存中为对象分配空间并返回一个指向该对象的指针，我们可以选择对对象初始化；delete接受一个动态对象的指针，销毁对象，并释放对应内存。使用示例如下：

 void Test()

 {

     int *pi1 = new int;

 //pi1指向一个动态分配的4个字节（int型）、未初始化的无名对象；*pi1的值未定义

     int *pi2 = new int();

 //pi2指向的对象的值是2，动态分配4个字节（ 1个 int） 的空间并初始化为2

     int *pi3 = new int[];        //动态分配12个字节（ 3个 int） 的空间

     int *pi4 = new int();         //值初始化为0；*pi4为0

     delete pi1;

     delete pi2;

     delete [] pi3;

     delete pi4;

 }

自由空间分配的内存是无名的，new无法为其分配的对象命名，而是返回一个指向该对象的指针。默认情况下，动态分配的对象是默认初始化的，即内置类型或组合类型的对象的值是未定义的，类类型的对象将用默认构造函数进行初始化。
new和delete、 new[] 和delete[] 一定匹配使用，一定匹配使用，一定匹配使用！！！
重要的事说三遍！否则可能出现内存泄露甚至崩溃的问题。
2、深入探究new和delete、 new[] 和delete[]内部实现机制

通过下面这段代码我们来详细比较一下new和delete、 new[] 和delete[]内部实现

 class Array

 {

     public :

     Array(size_t size = )//构造函数

         : _size(size)

         , _a()

     {

         cout << "Array(size_t size) " << endl;

         if (_size > )

         {

             _a = new int[size];

         }

     }

     ~Array()             //析构函数

     {

         cout << "~Array() " << endl;

         if (_a)

         {

             delete[] _a;

             _a = ;

             _size = ;

         }

     }

 private:

     int*_a;

     size_t _size;

 };

 void Test()

 {

     Array* p1 = (Array*)malloc(sizeof(Array));

     Array* p2 = new Array;

     Array* p3 = new Array();

     Array* p4 = new Array[];

     free(p1);

     delete p2;

     delete p3;

     delete[] p4;

 }

 int main()

 {

     Test();

     getchar();

     return ;

 }

转到反汇编可以看到，在call指令处调用了operator new：

转到定义处可以看到operator new 的具体原型：

其实在operator new的底层同样调用了malloc分配空间，它先为对象分配所申请的内存空间，然后底层调用构造函数构造对象

再按F10程序来到了构造函数

执行完之后，输出

此时new已经完成了申请空间的任务，且调用构造函数创建了对象。同样，detele的定义如下

而delete是先调用析构函数清除对象。然后调用operator detele释放空间。

按F10跳转到了析构函数，析构之后：

然后空间才被释放：

new []与delete []内部执行过程相同，只是底部调用的是operator new []和operator delete []

Array* p4 = new Array[10];
delete[] p4;

执行这两条语句的时候实际上调用operator new[](10*sizeof(Array)+4)分配大小为10*sizeof(Array)+4空间，其中多的四个字节空间用于存放N(10)这个数字以便于delete中调用析构函数析构对象（调用析构函数的次数），空间申请好了之后调用构造函数创建对象。delete[] p4执行的时候首先取N(10)对象个数，然后调用析构函数析构对象，最后用operator delete[]函数释放空间。

3、关键字之间的匹配使用问题

 void Test ()

 {

 // 以下代码没有匹配使用， 会发生什么？ 有内 存泄露吗？ 会崩 溃吗？

 int* p4 = new int;

 int* p5 = new int() ;

 int* p6 = new int[] ;

 int* p7 = (int*) malloc(sizeof (int) ) ;

 delete[] p4 ;

 delete p5 ;

 free(p5 ) ;

 delete p6 ;

 delete p7 ;

 }

运行结果：没有崩溃。但是当把int换成自定义类型之后则会出现问题。因为内置类型一般不会调用构造函数和析构函数，而自定义类型会，所以是析构对象的时候出现内存泄漏，导致程序崩溃。虽然弄清了问题，但还是建议任何类型都要匹配使用。

4、定位new表达式

new表达式，默认下把内存开辟到堆区。使用定位new表达式，可以在指定地址区域(栈区、堆区、静态区)构造对象，这好比是把内存开辟到指定区域。

定位new表达式调用 void *operator new(size_t, void *); 分配内存。其常见形式有：

     new(address) type;

     new(address) type(initializers);

     new(address) type[size];

     new(address) type[size]{braced initializer list};

address必须是个指针，指向已经分配好的内存。

示例代码：

 #include <iostream>

 using namespace std;

 char addr1[];  //把内存分配到全局/静态区

 int main()

 {

  char addr2[];  //把内存分配到栈区

  char *addr3 = new char[];  //把内存分配到堆区

  cout << "addr1 = " << (void*)addr1 << endl;

  cout << "addr2 = " << (void*)addr2 << endl;

  cout << "addr3 = " << (void*)addr3 << endl;

  int *p = nullptr;

  //把对象构造到静态区

  p = new(addr1)int;

  *p = ;

  cout << (void*)p << "  " << *p << endl;

  //把对象构造到栈区

  p = new(addr2)int;

  *p = ;

  cout << (void*)p << "  " << *p << endl;

  //把内存分配到堆区

  p = new(addr3)int;

  *p = ;

  cout << (void*)p << "  " << *p << endl;

  cin.get();

  return ;

 }

程序中，首先使用变量或new为对象分配空间，然后通过定位new表达式，完成构造函数的调用，将对象创建在已经被分配好的内存中。

定位new表达式不能调用delete删除 placement new的对象，需要人为的调用对象的析构函数，并且人为的释放掉占用的内存。

     #include <iostream>

     #include <new>   

     using namespace std;   

     const int chunk = ;   

     class Foo

     {

     public:

         int val(){return _val;}

         Foo(){_val=;}

     private:

         int _val;

     };   

     int main()

     {

         // 预分配内存buf

         char *buf = new char[sizeof(Foo) * chunk];   

         // 在buf中创建一个Foo对象

         Foo *pb=new (buf) Foo;

         // 检查一个对象是否被放在buf中

         if(pb->val()==) cout<<"new expression worked!"<<endl;

         // 这里不存在与定位new表达式匹配的delete表达式，即：delete pb, 其实只是为了

         // 释放内存的话，我们不需要这样的表达式，因为定位new表达式并不分配内存。

         // 如果在析构函数中要做一些其他的操作呢？就要显示的调用析构函数。

         // 当程序不再需要buf时，buf指向的内存被删除，它所包含的任何对象的生命期也就

         // 都结束了。   

         delete[] buf;

         return ;

     }

一句话：定位new表达式用于在已分配的原始空间中调用构造函数初始化一个对象。

5、模拟实现new和delete

 class Test

 {};

 Test* newdelete( )

 {

     Test* p1 = NULL;

     //1、分配空间     2.利用new的定位表达式显式调用构造函数

     if (p1 = (Test*)malloc(sizeof(Test)))

         return p1;

     else

         throw bad_alloc();  //内存分配失败时抛异常

     new(p1)Test;  //NEW(P1+I)Test(参数列表);

     //3、析构函数     4、释放空间

     p1->~Test();

     free(p1);

 }

 Test* newdalete_(size_t N)

 {

     Test* p2 = NULL;

     //1、分配空间     2.显示调用构造函数

     if (p2 = (Test*)malloc(sizeof(Test)*N + ))

         return p2;

     else

         throw bad_alloc();  //内存分配失败时抛异常

     *((int*)p2) = N;

     p2 = (Test*)((int*)p2 + );

     for (int i = ; i < N; ++i)

     {

         new(p2 + i)Test;

     }

     int n = *((int*)p2 - );

     //3、析构函数     4、释放空间

     for (int i = ; i < n; ++i)

     {

         p2[i].~Test();

         //(p1 + 1)->~AA();   //也可以

     }

     free((int*)p2 - );

 }

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

【 new作用】
调用operator new分配空间。
调用构造函数初始化对象。

【 delete作用】
调用析构函数清理对象
调用operator delete释放空间

【 new[] 作用】
调用operator new分配空间。
调用N次构造函数分别初始化每个对象。

【 delete[] 作用】
调用N次析构函数清理对象。调用operator delete释放空间。

巴特西

C++—动态内存管理之深入探究new和delete

3、关键字之间的匹配使用问题

4、定位new表达式

5、模拟实现new和delete

最新文章

热门文章