C++中的new delete

new的意义

当使用关键字new在堆上动态创建一个对象时，它实际上做了三件事：

    ① 获得一块内存空间

    ② 调用类构造函数

    ③ 返回指向地址的正确指针

如果创建的是简单类型的变量，第二步就不执行了。下面我们看一段代码：

#include <iostream>using namespace std;class A {    int m_value;public:    A(int value) :m_value(value * value){}    void Func(){        printf("m_value=%d\n", m_value);    }};int main(){    A *aPtr = new A(1);    delete *aPtr;    system("pause");    return 0;}

在调用 “A *a = new A(1);” 时，其过程大致如下：

  A *aPtr = (A*)malloc(sizeof(A)); // 分配内存区域     aPtr->A::A(1);                   // 调用对象构造函数     return aPtr;                     // 返回内存地址指针

上面三句话表面上看起来是得到了aPtr这个指向内存的指针。但是它与new自身的区别在于，当malloc失败的时候，上面的代码不会调用分配内存失败处理程序new_handler。而使用new的话就会。因此，我们要尽可能的使用new，避免一些不必要的麻烦。

下面的代码是微软对new的实现：

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)        {       // try to allocate size bytes        void *p;        while ((p = malloc(size)) == 0)                if (_callnewh(size) == 0)                {       // report no memory                static const std::bad_alloc nomem;                _RAISE(nomem);                }        return (p);        }

可以看到，它也是调用了malloc函数，但是还有一些其他的处理，这就是new比malloc稍微复杂，安全的原因。

※：不同编译器的实现也是不同的，这里只是分析了微软对new的实现，至于g++及其他的实现，还未及分析。

new的分类

C++中提到的new，至少可能代表以下三种含义：new operator、operator new、placement new。

   ①．new operator：    

我们平时使用的new，其行为如前所述的三步，事实上我们是不能更改它的行为的。

   ②．operator new： 

   从汇编码可以看出来，new operator的第一步是通过operator new完成的。这里的new就相当于一个运算符号，是可以重载的。它默认调用分配内存的代码，尝试得到一块堆上的内存空间，成功就返回；失败则调用new_handler。

operator new是可以重载的，下面就让我们来重载operator new试试看（严格术语上来说，应该是覆盖），我们把类A这样定义：

class A {    int m_value;public:    A(int value) :m_value(value * value){}    void Func(){        printf("m_value=%d\n", m_value);    }    void* operator new(size_t size){        printf("operator new called\n");        return ::operator new(size);    }};

然后执行 “A *a = new A(1);” 时，可以看到在Console里输出了一句"operator new called"，这说明operator new已经被我们重载了。这样我们就可以在分配内存前做一些我们想做的事，比如检测环境等等。

        ※：   "::operator new(size)" 这句话的作用是调用全局的operator new，因为分配内存的操作我们一般是不用重载的。

上面提到了全局的operator new，一般不重载，那么全局的operator new能不能被重载呢？答案是，可以。下面就让我们来重载全局的operator new来看看（严格术语上来说，应该是覆盖），在全局领域处插入如下代码：

1 void* operator new(size_t size) 2 { 3   printf("global new\n"); 4   return malloc(size); 5 } 

再次执行代码 “A *a = new A(1);” 可以看到，字符串"global new"被输出了。说明全局的operator new已经被我们重载了。当然，实际应用场景并不需要我们做这么复杂的操作。

上面我们说到过“当malloc失败的时候，上面的代码不会调用分配内存失败处理程序new_handler”，你可能会想自己定义new_handler的处理代码，事实上它是可以重载的，下面我们来重载试试看（严格术语上来说，应该是覆盖）：

#include <iostream>using namespace std;class A {    int m_value;    static new_handler    current_handler;public:    static new_handler set_new_handler(new_handler p){        new_handler old_handler = current_handler; //保存传入的Handler，返回以前的Handler        current_handler = p;        return old_handler;    }    void* operator new(size_t size){        new_handler globe_handler = std::set_new_handler(current_handler); // 调用全局函数set_new_handler设置handler        void *memory = NULL;        try{            memory = ::operator new(size);        }catch(std::bad_alloc){            std::set_new_handler(globe_handler);            throw;        }        std::set_new_handler(globe_handler);        return memory;    }    A(int value) :m_value(value * value){}};new_handler A::current_handler = NULL;void handlerFunc(){    cout<<"Bad Memory."<<endl;}int main(){    A::set_new_handler(handlerFunc);    A *aPtr = new A(1);    delete aPtr;    system("pause");    return 0;}

程序编译之后调试，可以看到我们的程序是可以捕获到着色代码行的异常的。这样就可以定义我们自己的异常处理函数了，比如销毁之前申请的资源等等。 

 ③. placement new

:  它的功能就相当于我们平常使用的new的本质代码的第二步——调用构造函数。下面看看它的使用方法。

#include <iostream>using namespace std;class A {    int m_value;public:    void* operator new(size_t size){        cout<<"operator new."<<endl;        void* memory = NULL;        memory = malloc(size);        return memory;    }    A(int value) :m_value(value * value){}};int main(){    A *aPtr = new A(1);    ::new(aPtr) A(1);//    delete aPtr;    system("pause");    return 0;}

上面着色代码的第二行就是placement new的使用方法，在该行断点后，按F11，可以看到它调用的代码，如下：

1 inline void *__CRTDECL operator new(size_t, void *_Where) _THROW0()2     {    // construct array with placement at _Where3     return (_Where);4     }

可以看到它与operator new的实现之间的区别，placement new有两个参数，一个传入大小，一个传入地址。而operator new的实现只有一个参数，即需要分配内存的大小。

其意义是在指定内存区域中分配内存。

需要注意的是使用placement new创建的对象，直接delete是无法自动调用析构函数的，所以需要显式调用，然后free(operator delete)或者直接delete整块指定内存

delete的意义

delete与new 是需要成对出现的，所以意义也相仿   

string *ps;

delete ps; //使用delete operator.

1）ps->~string();//调用析构函数

2）operator delete(ps);//释放对象所占用的内存

如果只打算处理原始的、未设初值的内存，应该完全回避 new operator和delete operator。

改为调用operator new取得内存并以operator delete归还系统。这组行为类似malloc和free。

例如：

void* buffer=operator new (50*sizeof(char));//分配内存，放置50个char,没有调用构造函数

...

operator delete(buffer); //释放内存，而没有直接调用析构函数

delete的使用

new用法:

          1.     开辟单变量地址空间

               1)new int;  //开辟一个存放数组的存储空间,返回一个指向该存储空间的地址.int *a = new int 即为将一个int类型的地址赋值给整型指针a. 

               2)int *a = new int(5) 作用同上,但是同时将整数赋值为5

          2.     开辟数组空间

               一维: int *a = new int[100];开辟一个大小为100的整型数组空间

               二维: int **a = new int[5][6]

               三维及其以上:依此类推.

         一般用法: new 类型 [初值]

delete用法:

          1. int *a = new int;

               delete a;   //释放单个int的空间

          2.int *a = new int[5];

               delete [] a; //释放int数组空间

所以一个简单的使用原则就是：

new 和 delete、

new[] 和 delete[] 对应使用。

当你在基类中发现只需要new 单个对象，但在派生类可能需要new[]多个对象，希望只写一个析构函数来统一的话，可以new [1]这样，delete []就可以统一了.