[C++基礎]033_深入C++的new

1. 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，避免一些不必要的麻煩。

下面是 “A *a = new A(1);” 的匯編碼（windows 7， Visual Studio 2008）：

    A *aPtr = new A(1);
0116140D  push        4    
0116140F  call operator new (1161190h) 
01161414  add         esp,4 
01161417  mov         dword ptr [ebp-0ECh],eax 
0116141D  mov         dword ptr [ebp-4],0 
01161424  cmp         dword ptr [ebp-0ECh],0 
0116142B  je          main+72h (1161442h) 
0116142D  push        1    
0116142F  mov         ecx,dword ptr [ebp-0ECh] 
01161435  call        A::A (1161019h) 
0116143A  mov         dword ptr [ebp-100h],eax 
01161440  jmp         main+7Ch (116144Ch) 
01161442  mov         dword ptr [ebp-100h],0 
0116144C  mov         eax,dword ptr [ebp-100h] 
01161452  mov         dword ptr [ebp-0F8h],eax 
01161458  mov         dword ptr [ebp-4],0FFFFFFFFh 
0116145F  mov         ecx,dword ptr [ebp-0F8h] 
01161465  mov         dword ptr [ebp-14h],ecx 

可以看出，在編譯成匯編碼的時候，也是先用new創建一塊內存，接着調用A的構造函數初始化，最后返回內存地址的指針。下面的代碼是微軟對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++及其他的實現，還未及分析。

2. New的分類

我們經常使用的new都是“new operator”和“new expression”，但事實上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){ 11         printf("operator new called\n");         return ::operator new(size); 13  } 14 };

        然后執行 “A *a = new A(1);” 時，可以看到在Console里輸出了一句"operator new called"，這說明operator new已經被我們重載了。這樣我們就可以在分配內存前做一些我們想做的事，比如檢測環境等等。

        ※：   "::operator new(size)" 這句話的作用是調用全局的operator new，因為分配內存的操作我們一般是不用重載的。

■上面提到了全局的operator new，一般不重載，那么全局的operator new能不能被重載呢？答案是，可以。下面就讓我們來重載全局的operator new來看看（嚴格術語上來說，應該是覆蓋），在全局領域處插入如下代碼：

void* operator new(size_t size) 
{ 
  printf("global new\n"); 
  return malloc(size); 
} 

再次執行代碼 “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); 20         }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); 19     ::new(aPtr) A(1); 20 
    delete aPtr;
    system("pause");
    return 0;
}

上面着色代碼的第二行就是placement new的使用方法，在該行斷點后，按F11，可以看到它調用的代碼，如下：

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

可以看到它與operator new的實現之間的區別，placement new有兩個參數，一個傳入大小，一個傳入地址。而operator new的實現只有一個參數，即需要分配內存的大小。

3. 總結

    ①．　C++的new有三重含義：new operator、operator new、placement new。

    ②．　new operator是我們經常使用的new，它的內部相當於實現了三步操作：分配內存、調用構造函數、返回地址指針。

    ③．　operator new可以看做運算符，可以重載，重載它可以做內存分配前后的一些工作。

    ④．　placement new就是調用構造函數，它的書寫方式比較特別：“::new(aPtr) A(1)”

 

 參考文檔

     http://wenku.baidu.com/view/30709e12a21614791711284b.html

     http://wenku.baidu.com/view/6b75ac81e53a580216fcfe6c.html