轉自：http://tech.e800.com.cn/articles/2010/56/1273126029787_1.html 

      “new”是C++的一個關鍵字，同時也是操作符。關于new的話題非常多，因為它確實比較復雜，也非常神秘，下面我將把我了解到的與new有關的內容做一個總結。

　　new的過程

　　當我們使用關鍵字new在堆上動態創建一個對象時，它實際上做了三件事：獲得一塊內存空間、調用構造函數、返回正確的指針。當然，如果我們創建的是簡單類型的變量，那么第二步會被省略。假如我們定義了如下一個類A：

　　class A

　　{

　　int i;

　　public:

　　A(int _i) :i(_i*_i) {}

　　void Say()  { printf("i=%dn", i); }

　　};

　　//調用new：

　　A* pa = new A(3);

　　那么上述動態創建一個對象的過程大致相當于以下三句話（只是大致上）：

　　A* pa = (A*)malloc(sizeof(A));

　　pa->A::A(3);

　　return pa;

　　雖然從效果上看，這三句話也得到了一個有效的指向堆上的A對象的指針pa，但區別在于，當malloc失敗時，它不會調用分配內存失敗處理程序new_handler，而使用new的話會的。因此我們還是要盡可能的使用new，除非有一些特殊的需求。

　　new的三種形態

　　到目前為止，本文所提到的new都是指的“new operator”或稱為“new expression”，但事實上在C++中一提到new，至少可能代表以下三種含義：new operator、operator new、placement new。

　　new operator就是我們平時所使用的new，其行為就是前面所說的三個步驟，我們不能更改它。但具體到某一步驟中的行為，如果它不滿足我們的具體要求 時，我們是有可能更改它的。三個步驟中最后一步只是簡單的做一個指針的類型轉換，沒什么可說的，并且在編譯出的代碼中也并不需要這種轉換，只是人為的認識 罷了。但前兩步就有些內容了。

　　new operator的第一步分配內存實際上是通過調用operator new來完成的，這里的new實際上是像加減乘除一樣的操作符，因此也是可以重載的。operator new默認情況下首先調用分配內存的代碼，嘗試得到一段堆上的空間，如果成功就返回，如果失敗，則轉而去調用一個new_hander，然后繼續重復前面 過程。如果我們對這個過程不滿意，就可以重載operator new，來設置我們希望的行為。例如：

　　class A

　　{

　　public:

　　void* operator new(size_t size)

　　{

　　printf("operator new calledn");

　　return ::operator new(size);

　　}

　　};

　　A* a = new A();

　　這里通過::operator new調用了原有的全局的new，實現了在分配內存之前輸出一句話。全局的operator new也是可以重載的，但這樣一來就不能再遞歸的使用new來分配內存，而只能使用malloc了：

　　void* operator new(size_t size)

　　{

　　printf("global newn");

　　return malloc(size);

　　}

　　相應的，delete也有delete operator和operator delete之分，后者也是可以重載的。并且，如果重載了operator new，就應該也相應的重載operator delete，這是良好的編程習慣。

　　new的第三種形態--placement new是用來實現定位構造的，因此可以實現new operator三步操作中的第二步，也就是在取得了一塊可以容納指定類型對象的內存后，在這塊內存上構造一個對象，這有點類似于前面代碼中的 “p->A::A(3);”這句話，但這并不是一個標準的寫法，正確的寫法是使用placement new：

　　#include

　　void main()

　　{

　　char s[sizeof(A)];

　　A* p = (A*)s;

　　new(p) A(3); //p->A::A(3);

　　p->Say();

　　}

對頭文件或的引用是必須的，這樣才 可以使用placement new。這里“new(p) A(3)”這種奇怪的寫法便是placement new了，它實現了在指定內存地址上用指定類型的構造函數來構造一個對象的功能，后面A(3)就是對構造函數的顯式調用。這里不難發現，這塊指定的地址既 可以是棧，又可以是堆，placement對此不加區分。但是，除非特別必要，不要直接使用placement new ，這畢竟不是用來構造對象的正式寫法，只不過是new operator的一個步驟而已。使用new operator地編譯器會自動生成對placement new的調用的代碼，因此也會相應的生成使用delete時調用析構函數的代碼。如果是像上面那樣在棧上使用了placement new，則必須手工調用析構函數，這也是顯式調用析構函數的唯一情況：

　　p->~A();

　　當我們覺得默認的new operator對內存的管理不能滿足我們的需要，而希望自己手工的管理內存時，placement new就有用了。STL中的allocator就使用了這種方式，借助placement new來實現更靈活有效的內存管理。

　　處理內存分配異常

　　正如前面所說，operator new的默認行為是請求分配內存，如果成功則返回此內存地址，如果失敗則調用一個new_handler，然后再重復此過程。于是，想要從operator new的執行過程中返回，則必然需要滿足下列條件之一：

　　* 分配內存成功

　　* new_handler中拋出bad_alloc異常

　　* new_handler中調用exit()或類似的函數，使程序結束

　　于是，我們可以假設默認情況下operator new的行為是這樣的：

　　void* operator new(size_t size)

　　{

　　void* p = null

　　while(!(p = malloc(size)))

　　{

　　if(null == new_handler)

　　throw bad_alloc();

　　try

　　{

　　new_handler();

　　}

　　catch(bad_alloc e)

　　{

　　throw e;

　　}

　　catch(…)

　　{}

　　}

　　return p;

　　}

　　在默認情況下，new_handler的行為是拋出一個bad_alloc異常，因此 上述循環只會執行一次。但如果我們不希望使用默認行為，可以自定義一個new_handler，并使用std::set_new_handler函數使其 生效。在自定義的new_handler中，我們可以拋出異常，可以結束程序，也可以運行一些代碼使得有可能有內存被空閑出來，從而下一次分配時也許會成 功，也可以通過set_new_handler來安裝另一個可能更有效的new_handler。例如：

　　void MyNewHandler()

　　{

　　printf(“New handler called!n”);

　　throw std::bad_alloc();

　　}

　　std::set_new_handler(MyNewHandler);

　　這里new_handler程序在拋出異常之前會輸出一句話。應該注意，在 new_handler的代碼里應該注意避免再嵌套有對new的調用，因為如果這里調用new再失敗的話，可能會再導致對new_handler的調用， 從而導致無限遞歸調用。--這是我猜的，并沒有嘗試過。

　　在編程時我們應該注意到對new的調用是有可能有異常被拋出的，因此在new的代碼周圍應該注意保持其事務性，即不能因為調用new失敗拋出異常來導致不正確的程序邏輯或數據結構的出現。例如：

　　class SomeClass

　　{

　　static int count;

　　SomeClass() {}

　　public:

　　static SomeClass* GetNewInstance()

　　{

　　count++;

　　return new SomeClass();

　　}

　　};

靜態變量count用于記錄此類型生成的實例的個數，在上述代碼中，如果因new分配內存失敗而拋出異常，那么其實例個數并沒有增加，但count變量的值卻已經多了一個，從而數據結構被破壞。正確的寫法是：

　　static SomeClass* GetNewInstance()

　　{

　　SomeClass* p = new SomeClass();

　　count++;

　　return p;

　　}

　　這樣一來，如果new失敗則直接拋出異常，count的值不會增加。類似的，在處理線程同步時，也要注意類似的問題：

　　void SomeFunc()

　　{

　　lock(someMutex); //加一個鎖

　　delete p;

　　p = new SomeClass();

　　unlock(someMutex);

　　}

　　此時，如果new失敗，unlock將不會被執行，于是不僅造成了一個指向不正確地址的指針p的存在，還將導致someMutex永遠不會被解鎖。這種情況是要注意避免的。（參考：C++箴言：爭取異常安全的代碼） <http://dev.yesky.com/490/2087990.shtml>

　　STL的內存分配與traits技巧

　　在《STL原碼剖析》一書中詳細分析了SGI STL的內存分配器的行為。與直接使用new operator不同的是，SGI STL并不依賴C++默認的內存分配方式，而是使用一套自行實現的方案。首先SGI STL將可用內存整塊的分配，使之成為當前進程可用的內存，當程序中確實需要分配內存時，先從這些已請求好的大內存塊中嘗試取得內存，如果失敗的話再嘗試 整塊的分配大內存。這種做法有效的避免了大量內存碎片的出現，提高了內存管理效率。

　　為了實現這種方式，STL使用了placement new，通過在自己管理的內存空間上使用placement new來構造對象，以達到原有new operator所具有的功能。

　　template

　　inline void construct(T1* p, const T2& value)

　　{

　　new(p) T1(value);

　　}

　　此函數接收一個已構造的對象，通過拷貝構造的方式在給定的內存地址p上構造一個新對 象，代碼中后半截T1(value)便是placement new語法中調用構造函數的寫法，如果傳入的對象value正是所要求的類型T1，那么這里就相當于調用拷貝構造函數。類似的，因使用了 placement new，編譯器不會自動產生調用析構函數的代碼，需要手工的實現：

　　template

　　inline void destory(T* pointer)

　　{

　　pointer->~T();

　　}

　　與此同時，STL中還有一個接收兩個迭代器的destory版本，可將某容器上指定范 圍內的對象全部銷毀。典型的實現方式就是通過一個循環來對此范圍內的對象逐一調用析構函數。如果所傳入的對象是非簡單類型，這樣做是必要的，但如果傳入的 是簡單類型，或者根本沒有必要調用析構函數的自定義類型（例如只包含數個int成員的結構體），那么再逐一調用析構函數是沒有必要的，也浪費了時間。為 此，STL使用了一種稱為“type traits”的技巧，在編譯器就判斷出所傳入的類型是否需要調用析構函數：

　　template

　　inline void destory(ForwardIterator first, ForwardIterator last)

　　{

　　__destory(first, last, value_type(first));

　　}

　　其中value_type()用于取出迭代器所指向的對象的類型信息，于是：

　　template

　　inline void __destory(ForwardIterator first, ForwardIterator last, T*)

　　{

　　typedef typename __type_traits::has_trivial_destructor trivial_destructor;

　　__destory_aux(first, last, trivial_destructor());

　　}

　　//如果需要調用析構函數：

　　template

　　inline void __destory_aux(ForwardIterator first, ForwardIterator last, __false_type)

　　{

　　for(; first < last; ++first)

　　destory(&*first); //因first是迭代器，*first取出其真正內容，然后再用&取地址

　　}

　　//如果不需要，就什么也不做：

　　tempalte

　　inline void __destory_aux(ForwardIterator first, ForwardIterator last, __true_type)

　　{}

　　因上述函數全都是inline的，所以多層的函數調用并不會對性能造成影響，最終編譯 的結果根據具體的類型就只是一個for循環或者什么都沒有。這里的關鍵在于__type_traits這個模板類上，它根據不同的T類 型定義出不同的has_trivial_destructor的結果，如果T是簡單類型，就定義為__true_type類型，否則就定義為 __false_type類型。其中__true_type、__false_type只不過是兩個沒有任何內容的類，對程序的執行結果沒有什么意義，但 在編譯器看來它對模板如何特化就具有非常重要的指導意義了，正如上面代碼所示的那樣。__type_traits也是特化了的一系列模 板類：

　　struct __true_type {};

　　struct __false_type {};

　　template

　　struct __type_traits

　　{

　　public:

　　typedef __false _type has_trivial_destructor;

　　……

　　};

　　template<> //模板特化

　　struct __type_traits    //int的特化版本

　　{

　　public:

　　typedef __true_type has_trivial_destructor;

　　……

　　};

　　…… //其他簡單類型的特化版本

　　如果要把一個自定義的類型MyClass也定義為不調用析構函數，只需要相應的定義__type_traits的一個特化版本即可：

　　template<>

　　struct __type_traits

　　{

　　public:

　　typedef __true_type has_trivial_destructor;

　　……

　　};

　模板是比較高級的C++編程技巧，模板特化、模板偏特化就更是技巧性很強的東 西，STL中的type_traits充分借助模板特化的功能，實現了在程序編譯期通過編譯器來決定為每一處調用使用哪個特化版本，于是在不增加編程復雜 性的前提下大大提高了程序的運行效率。更詳細的內容可參考《STL源碼剖析》第二、三章中的相關內容。

　　帶有“[]”的new和delete

　　我們經常會通過new來動態創建一個數組，例如：

　　char* s = new char[100];

　　……

　　delete s;

　　嚴格的說，上述代碼是不正確的，因為我們在分配內存時使用的是new[]，而并不是簡單的new，但釋放內存時卻用的是delete。正確的寫法是使用delete[]：

　　delete[] s;

　　但是，上述錯誤的代碼似乎也能編譯執行，并不會帶來什么錯誤。事實上，new與new[]、delete與delete[]是有區別的，特別是當用來操作復雜類型時。假如針對一個我們自定義的類MyClass使用new[]：

　　MyClass* p = new MyClass[10];

　　上述代碼的結果是在堆上分配了10個連續的MyClass實例，并且已經對它們依次調 用了構造函數，于是我們得到了10個可用的對象，這一點與Java、C#有區別的，Java、C#中這樣的結果只是得到了10個null。換句話說，使用 這種寫法時MyClass必須擁有不帶參數的構造函數，否則會發現編譯期錯誤，因為編譯器無法調用有參數的構造函數。

　　當這樣構造成功后，我們可以再將其釋放，釋放時使用delete[]：

　　delete[] p;

　　當我們對動態分配的數組調用delete[]時，其行為根據所申請的變量類型會有所不 同。如果p指向簡單類型，如int、char等，其結果只不過是這塊內存被回收，此時使用delete[]與delete沒有區別，但如果p指向的是復雜 類型，delete[]會針對動態分配得到的每個對象調用析構函數，然后再釋放內存。因此，如果我們對上述分配得到的p指針直接使用delete來回收， 雖然編譯期不報什么錯誤（因為編譯器根本看不出來這個指針p是如何分配的），但在運行時（DEBUG情況下）會給出一個Debug assertion failed提示。

　　到這里，我們很容易提出一個問題--delete[]是如何知道要為多少個對象調用析構函數的？要回答這個問題，我們可以首先看一看new[]的重載。

　　class MyClass

　　{

　　int a;

　　public:

　　MyClass() { printf("ctorn"); }

　　~MyClass() { printf("dtorn"); }

　　};

　　void* operator new[](size_t size)

　　{

　　void* p = operator new(size);

　　printf("calling new[] with size=%d address=%pn", size, p);

　　return p;

　　}

　　// 主函數

　　MyClass* mc = new MyClass[3];

　　printf("address of mc=%pn", mc);

　　delete[] mc;

　　運行此段代碼，得到的結果為：（VC2005）

　　calling new[] with size=16 address=003A5A58

　　ctor

　　ctor

　　ctor

　　address of mc=003A5A5C

　　dtor

　　dtor

　　dtor

　　雖然對構造函數和析構函數的調用結果都在預料之中，但所申請的內存空間大小以及地址的 數值卻出現了問題。我們的類MyClass的大小顯然是4個字節，并且申請的數組中有3個元素，那么應該一共申請12個字節才對，但事實上系統卻為我們申 請了16字節，并且在operator new[]返后我們得到的內存地址是實際申請得到的內存地址值加4的結果。也就是說，當為復雜類型動態分配數組時，系統自動在最終得到的內存地址前空出了 4個字節，我們有理由相信這4個字節的內容與動態分配數組的長度有關。通過單步跟蹤，很容易發現這4個字節對應的int值為0x00000003，也就是 說記錄的是我們分配的對象的個數。改變一下分配的個數然后再次觀察的結果證實了我的想法。于是，我們也有理由認為new[] operator的行為相當于下面的偽代碼：

　　template

　　T* New[](int count)

　　{

　　int size = sizeof(T) * count + 4;

　　void* p = T::operator new[](size);

　　*(int*)p = count;

　　T* pt = (T*)((int)p + 4);

　　for(int i = 0; i < count; i++)

　　new(&pt[i]) T();

　　return pt;

　　}

　上述示意性的代碼省略了異常處理的部分，只是展示當我們對一個復雜類型使用new[] 來動態分配數組時其真正的行為是什么，從中可以看到它分配了比預期多4個字節的內存并用它來保存對象的個數，然后對于后面每一塊空間使用 placement new來調用無參構造函數，這也就解釋了為什么這種情況下類必須有無參構造函數，最后再將首地址返回。類似的，我們很容易寫出相應的delete[]的實 現代碼：

　　template

　　void Delete[](T* pt)

　　{

　　int count = ((int*)pt)[-1];

　　for(int i = 0; i < count; i++)

　　pt[i].~T();

　　void* p = (void*)((int)pt - 4);

　　T::operator delete[](p);

　　}

　　由此可見，在默認情況下operator new[]與operator new的行為是相同的，operator delete[]與operator delete也是，不同的是new operator與new[] operator、delete operator與delete[] operator。當然，我們可以根據不同的需要來選擇重載帶有和不帶有“[]”的operator new和delete，以滿足不同的具體需求。

　　把前面類MyClass的代碼稍做修改--注釋掉析構函數，然后再來看看程序的輸出：

　　calling new[] with size=12 address=003A5A58

　　ctor

　　ctor

　　ctor

　　address of mc=003A5A58

　　這一次，new[]老老實實的申請了12個字節的內存，并且申請的結果與new[] operator返回的結果也是相同的，看來，是否在前面添加4個字節，只取決于這個類有沒有析構函數，當然，這么說并不確切，正確的說法是這個類是否需 要調用構造函數，因為如下兩種情況下雖然這個類沒聲明析構函數，但還是多申請了4個字節：一是這個類中擁有需要調用析構函數的成員，二是這個類繼承自需要 調用析構函數的類。于是，我們可以遞歸的定義“需要調用析構函數的類”為以下三種情況之一：

　　1 顯式的聲明了析構函數的

　　2 擁有需要調用析構函數的類的成員的

　　3 繼承自需要調用析構函數的類的

　　類似的，動態申請簡單類型的數組時，也不會多申請4個字節。于是在這兩種情況下，釋放內存時使用delete或delete[]都可以，但為養成良好的習慣，我們還是應該注意只要是動態分配的數組，釋放時就使用delete[]。

　　釋放內存時如何知道長度

　　但這同時又帶來了新問題，既然申請無需調用析構函數的類或簡單類型的數組時并沒有記錄 個數信息，那么operator delete，或更直接的說free()是如何來回收這塊內存的呢？這就要研究malloc()返回的內存的結構了。與new[]類似的是，實際上在 malloc()申請內存時也多申請了數個字節的內容，只不過這與所申請的變量的類型沒有任何關系，我們從調用malloc時所傳入的參數也可以理解這一 點--它只接收了要申請的內存的長度，并不關系這塊內存用來保存什么類型。下面運行這樣一段代碼做個實驗：

　　char *p = 0;

　　for(int i = 0; i < 40; i += 4)

　　{

　　char* s = new char[i];

　　printf("alloc %2d bytes, address=%p distance=%dn", i, s, s - p);

　　p = s;

　　}

　　我們直接來看VC2005下Release版本的運行結果，DEBUG版因包含了較多的調試信息，這里就不分析了：

　　alloc 0 bytes, address=003A36F0 distance=3815152

　　alloc 4 bytes, address=003A3700 distance=16

　　alloc 8 bytes, address=003A3710 distance=16

　　alloc 12 bytes, address=003A3720 distance=16

　　alloc 16 bytes, address=003A3738 distance=24

　　alloc 20 bytes, address=003A84C0 distance=19848

　　alloc 24 bytes, address=003A84E0 distance=32

　　alloc 28 bytes, address=003A8500 distance=32

　　alloc 32 bytes, address=003A8528 distance=40

　　alloc 36 bytes, address=003A8550 distance=40

　　每一次分配的字節數都比上一次多4，distance值記錄著與上一次分配的差值，第 一個差值沒有實際意義，中間有一個較大的差值，可能是這塊內存已經被分配了，于是也忽略它。結果中最小的差值為16字節，直到我們申請16字節時，這個差 值變成了24，后面也有類似的規律，那么我們可以認為申請所得的內存結構是如下這樣的：

 

　　從圖中不難看出，當我們要分配一段內存時，所得的內存地址和上一次的尾地址至少要相距8個字節（在DEBUG版中還要更多），那么我們可以猜想，這8個字節中應該記錄著與這段所分配的內存有關的信息。觀察這8個節內的內容，得到結果如下：

 

　　圖中右邊為每次分配所得的地址之前8個字節的內容的16進制表示，從圖中紅線所表示可 以看到，這8個字節中的第一個字節乘以8即得到相臨兩次分配時的距離，經過試驗一次性分配更大的長度可知，第二個字節也是這個意義，并且代表高8位，也就 說前面空的這8個字節中的前兩個字節記錄了一次分配內存的長度信息，后面的六個字節可能與空閑內存鏈表的信息有關，在翻譯內存時用來提供必要的信息。這就 解答了前面提出的問題，原來C/C++在分配內存時已經記錄了足夠充分的信息用于回收內存，只不過我們平常不關心它罷了。