new/new[]和delete/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(2);        
//pi2指向的对象的值是2，动态分配4个字节（ 1个 int） 的空间并初始化为2
    int *pi3 = new int[3];        //动态分配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 = 10)//构造函数
        : _size(size)
        , _a(0)
    {
        cout << "Array(size_t size) " << endl;
        if (_size > 0)
        {
            _a = new int[size];
        }
    }
    ~Array()             //析构函数
    {
        cout << "~Array() " << endl;
        if (_a)
        {
            delete[] _a;
            _a = 0;
            _size = 0;
        }
    }
private:
    int*_a;
    size_t _size;
};
void Test()
{
    Array* p1 = (Array*)malloc(sizeof(Array));
    Array* p2 = new Array;
    Array* p3 = new Array(20);
    Array* p4 = new Array[10];
    free(p1);
    delete p2;
    delete p3;
    delete[] p4;
}
int main()
{
    Test();
    getchar();
    return 0;
}

转到反汇编可以看到，在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(3) ;
int* p6 = new int[3] ;
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[100];  //把内存分配到全局/静态区
int main()
{
 char addr2[100];  //把内存分配到栈区
 char *addr3 = new char[100];  //把内存分配到堆区
 cout << "addr1 = " << (void*)addr1 << endl;
 cout << "addr2 = " << (void*)addr2 << endl;
 cout << "addr3 = " << (void*)addr3 << endl;
 int *p = nullptr;
 //把对象构造到静态区
 p = new(addr1)int;
 *p = 1;
 cout << (void*)p << "  " << *p << endl;
 //把对象构造到栈区
 p = new(addr2)int;
 *p = 2;
 cout << (void*)p << "  " << *p << endl;
 //把内存分配到堆区
 p = new(addr3)int;
 *p = 3;
 cout << (void*)p << "  " << *p << endl;
 cin.get();
 return 0;
}

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

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

    #include <iostream>   
    #include <new>   
      
    using namespace std;   
      
    const int chunk = 16;   
      
    class Foo   
    {   
    public:   
        int val(){return _val;}   
        Foo(){_val=0;}   
    private:   
        int _val;   
    };   
      
    int main()   
    {   
        // 预分配内存buf   
        char *buf = new char[sizeof(Foo) * chunk];   
      
        // 在buf中创建一个Foo对象  
        Foo *pb=new (buf) Foo;   
        // 检查一个对象是否被放在buf中  
        if(pb->val()==0) cout<<"new expression worked!"<<endl;   
        // 这里不存在与定位new表达式匹配的delete表达式，即：delete pb, 其实只是为了  
        // 释放内存的话，我们不需要这样的表达式，因为定位new表达式并不分配内存。  
        // 如果在析构函数中要做一些其他的操作呢？就要显示的调用析构函数。  
        // 当程序不再需要buf时，buf指向的内存被删除，它所包含的任何对象的生命期也就  
        // 都结束了。   
      
        delete[] buf;   
        return 0;   
    }  

一句话：定位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 + 4))
        return p2;
    else
        throw bad_alloc();  //内存分配失败时抛异常
    *((int*)p2) = N;
    p2 = (Test*)((int*)p2 + 1); 
    for (int i = 0; i < N; ++i)
    {
        new(p2 + i)Test;
    }

    int n = *((int*)p2 - 1);
    //3、析构函数     4、释放空间 
    for (int i = 0; i < n; ++i)
    {
        p2[i].~Test();
        //(p1 + 1)->~AA();   //也可以  
    }
    free((int*)p2 - 1);
}

总结:
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释放空间。