C++ 記憶體分配(new，operator new)詳解

WUDAIJUN的部落格發表於2016-10-23
C++記憶體

本文主要講述C++ new運算子和operator new, placement new之間的種種關聯，new的底層實現，以及operator new的過載和一些在記憶體池，STL中的應用。

一 new 運算子和 operator new()：

new：指我們在C++裡通常用到的運算子，比如A* a = new A;  對於new來說，有new和::new之分，前者位於std

operator new()：指對new的過載形式，它是一個函式，並不是運算子。對於operator new來說，分為全域性過載和類過載，全域性過載是void* ::operator new(size_t size)，在類中過載形式 void* A::operator new(size_t size)。還要注意的是這裡的operator new()完成的操作一般只是分配記憶體，事實上系統預設的全域性::operator new(size_t size)也只是呼叫malloc分配記憶體，並且返回一個void*指標。而建構函式的呼叫(如果需要)是在new運算子中完成的。

先簡單解釋一下new和operator new之間的關係：

關於這兩者的關係，我找到一段比較經典的描述（來自於www.cplusplus.com 見參考文獻）：

operator new can be called explicitly as a regular function, but in C++, new is an operator with a very specific behavior: An expression with the new operator, first calls function operator new (i.e., this function) with the size of its type specifier as first argument, and if this is successful, it then automatically initializes or constructs the object (if needed). Finally, the expression evaluates as a pointer to the appropriate type.

比如我們寫如下程式碼：

A* a = new A;

我們知道這裡分為兩步：1.分配記憶體，2.呼叫A()構造物件。事實上，分配記憶體這一操作就是由operator new(size_t)來完成的，如果類A過載了operator new，那麼將呼叫A::operator new(size_t )，如果沒有過載，就呼叫::operator new(size_t )，全域性new操作符由C++預設提供。因此前面的兩步也就是：1.呼叫operator new 2.呼叫建構函式。這裡再一次提出來是因為後面關於這兩步會有一些變形，在關於placement new那裡會講到。

先舉個簡單例子

//平臺：Visual Stdio 2008  
#include<iostream>  
class A  
{  
public:  
     A()  
     {  
          std::cout<<"call A constructor"<<std::endl;  
     }  

     ~A()  
     {  
          std::cout<<"call A destructor"<<std::endl;  
     }  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  

     A* a = new A;  
     delete a;  

     system("pause");  
     return 0;  
}

下面我們跟蹤一下A反彙編程式碼，由於Debug版本反彙編跳轉太多，因此此處通過Release版本在A* a = new A;處設斷點反彙編：
在Release版本中，建構函式和解構函式都是直接展開的。

A* a = new A;  
01301022  push        1    ;不含資料成員的類佔用一位元組空間，此處壓入sizeof(A)  
01301024  call        operator new (13013C2h) ;呼叫operator new(size_t size)  
01301029  mov         esi,eax ;返回值儲存到esi  
0130102B  add         esp,4 ;平衡棧  
0130102E  mov         dword ptr [esp+8],esi ;  
01301032  mov         dword ptr [esp+14h],0   
0130103A  test        esi,esi ;在operator new之後，檢查其返回值，如果為空(分配失敗)，則不呼叫A()建構函式  
0130103C  je          wmain+62h (1301062h) ;為空 跳過建構函式部分  
0130103E  mov         eax,dword ptr [__imp_std::endl (1302038h)] ;建構函式內部，輸出字串  
01301043  mov         ecx,dword ptr [__imp_std::cout (1302050h)]   
01301049  push        eax    
0130104A  push        offset string "call A constructor" (1302134h)   
0130104F  push        ecx    
01301050  call        std::operator<<<std::char_traits<char> > (13011F0h)   
01301055  add         esp,8   
01301058  mov         ecx,eax   
0130105A  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (1302040h)]   
01301060  jmp         wmain+64h (1301064h) ;構造完成，跳過下一句  
01301062  xor         esi,esi ;將esi置空，這裡的esi即為new A的返回值  
01301064  mov         dword ptr [esp+14h],0FFFFFFFFh   
    delete a;  
0130106C  test        esi,esi ;檢查a是否為空  
0130106E  je          wmain+9Bh (130109Bh) ;如果為空，跳過解構函式和operator delete  
01301070  mov         edx,dword ptr [__imp_std::endl (1302038h)] ;解構函式 輸出字串  
01301076  mov         eax,dword ptr [__imp_std::cout (1302050h)]   
0130107B  push        edx    
0130107C  push        offset string "call A destructor" (1302148h)   
01301081  push        eax    
01301082  call        std::operator<<<std::char_traits<char> > (13011F0h)   
01301087  add         esp,8   
0130108A  mov         ecx,eax   
0130108C  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (1302040h)]   
01301092  push        esi  ;壓入a   
01301093  call        operator delete (13013BCh) ;呼叫operator delete   
01301098  add         esp,4   
通過反彙編可以看出A* = new A包含了operator new(sizeof(A))和A()兩個步驟(當然，最後還要將值返回到a)  
         delete a包含了~A()和operator delete(a)兩個步驟。

二 operator new 的三種形式：

operator new有三種形式：

throwing (1)

void* operator new (std::size_t size) throw (std::bad_alloc);

nothrow (2)

void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) throw();

placement (3)

void* operator new (std::size_t size, void* ptr) throw();

(1)(2)的區別僅是是否丟擲異常，當分配失敗時，前者會丟擲bad_alloc異常，後者返回null，不會丟擲異常。它們都分配一個固定大小的連續記憶體。

用法示例：

A* a = new A; //呼叫throwing(1)
A* a = new(std::nothrow) A; //呼叫nothrow(2)

（3）是placement new，它也是對operator new的一個過載，定義於中，它多接收一個ptr引數，但它只是簡單地返回ptr。

其在new.h下的原始碼如下：

#define __PLACEMENT_NEW_INLINE  
inline void *__cdecl operator new(size_t, void *_P)  
        {return (_P); }  
#if     _MSC_VER >= 1200  
inline void __cdecl operator delete(void *, void *)  
    {return; }  
#endif  
#endif

那麼它究竟有什麼用呢？事實上，它可以實現在ptr所指地址上構建一個物件(通過呼叫其建構函式)，這在記憶體池技術上有廣泛應用。
它的呼叫形式為：

new(p) A(); //也可用A(5)等有參建構函式。

前面說到，new運算子都會呼叫operator new，而這裡的operator new(size_t, void*)並沒有什麼作用，真正起作用的是new運算子的第二個步驟：在p處呼叫A建構函式。這裡的p可以是動態分配的記憶體，也可以是棧中緩衝，如char buf[100]; new(buf) A();

我們仍然可以通過一個例子來驗證：

#include <iostream>  
class A  
{  
public:  
    A()  
    {  
        std::cout<<"call A constructor"<<std::endl;  
    }  

    ~A()  
    {  
        std::cout<<"call A destructor"<<std::endl;  
    }  
};  
int _tmain(int argc, _TCHAR* argv[])  
{  

    A* p = (A*)::operator new(sizeof(A)); //分配  

    new(p) A(); //構造  

    p->~A(); //析構  

    ::operator delete(p); //釋放  

    system("pause");  
    return 0;  
}

上面的程式碼將物件的分配，構造，析構和釋放分離開來，這也是new和delete運算子兩句就能完成的操作。

先直接執行可以看到程式輸出：

再分別註釋掉new(a) A();和a->~A();兩句，可以看到對應的構造和解構函式將不會被呼叫。

然後檢視反彙編：

平臺: Visual Studio 2008 Debug版

A* a = (A*)::operator new(sizeof(A)); //分配  
00F9151D  push        1      
00F9151F  call        operator new (0F91208h) ;呼叫::operator new(size_t size)也就是throwing(1)版本  
00F91524  add         esp,4   
00F91527  mov         dword ptr [ebp-14h],eax ;返回地址放入[ebp-14h] 即為p  

    new(a) A(); //構造  
00F9152A  mov         eax,dword ptr [ebp-14h]   
00F9152D  push        eax    
00F9152E  push        1    ;壓入p  
00F91530  call        operator new (0F91280h);呼叫operator new(size_t, void* p)即placement(3)版本 只是簡單返回p  
00F91535  add         esp,8   
00F91538  mov         dword ptr [ebp-0E0h],eax ;將p放入[ebp-0E0h]  
00F9153E  mov         dword ptr [ebp-4],0   
00F91545  cmp         dword ptr [ebp-0E0h],0   ;判斷p是否為空  
00F9154C  je          wmain+81h (0F91561h)     ;如果為空 跳過建構函式  
00F9154E  mov         ecx,dword ptr [ebp-0E0h] ;取出p到ecx  
00F91554  call        A::A (0F91285h)          ;呼叫建構函式 根據_thiscall呼叫約定 this指標通過ecx暫存器傳遞  
00F91559  mov         dword ptr [ebp-0F4h],eax ;將返回值(this指標)放入[ebp-0F4h]中  
00F9155F  jmp         wmain+8Bh (0F9156Bh)     ;跳過下一句  
00F91561  mov         dword ptr [ebp-0F4h],0   ;將[ebp-0F4h]置空 當前面判斷p為空時執行此語句  
00F9156B  mov         ecx,dword ptr [ebp-0F4h] ;[ebp-0F4h]為最終構造完成後的this指標(或者為空) 放入ecx  
00F91571  mov         dword ptr [ebp-0ECh],ecx ;又將this放入[ebp-0ECh] 這些都是除錯所用  
00F91577  mov         dword ptr [ebp-4],0FFFFFFFFh   

    a->~A(); //析構  
00F9157E  push        0      
00F91580  mov         ecx,dword ptr [ebp-14h] ;從[ebp-14h]中取出p  
00F91583  call        A::`scalar deleting destructor' (0F91041h) ;呼叫解構函式(跟蹤進去比較複雜 如果在Release下，構造解構函式都是直接展開的)  

    ::operator delete(a); //釋放  
00F91588  mov         eax,dword ptr [ebp-14h]   ;將p放入eax  
00F9158B  push        eax           ;壓入p  
00F9158C  call        operator delete (0F910B9h);呼叫operator delete(void* )  
00F91591  add         esp,4

從反彙編中可以看出，其實operator new呼叫了兩次，只不過每一次呼叫不同的過載函式，並且placement new的主要作用只是將p放入ecx，並且呼叫其建構函式。

事實上，在指定地址上構造物件還有另一種方法，即手動呼叫建構函式：p->A::A(); 這裡要加上A::作用域，否則編譯器會報錯：error C2273: “函式樣式轉換”: 位於“->”運算子右邊時非法

用p->A::A();替換掉new(p) A();仍然能達到同樣的效果，反彙編：

A* a = (A*)::operator new(sizeof(A)); //分配  
010614FE  push        1      
01061500  call        operator new (1061208h)   
01061505  add         esp,4   
01061508  mov         dword ptr [a],eax   

    //new(a) A();   //構造  
    a->A::A();  
0106150B  mov         ecx,dword ptr [a]   
0106150E  call        operator new (1061285h)   

    a->~A(); //析構  
01061513  push        0      
01061515  mov         ecx,dword ptr [a]   
01061518  call        A::`scalar deleting destructor' (1061041h)   

    ::operator delete(a); //釋放  
0106151D  mov         eax,dword ptr [a]   
01061520  push        eax    
01061521  call        operator delete (10610B9h)   
01061526  add         esp,4

比之前的方法更加簡潔高效(不需要呼叫placement new)。不知道手動呼叫建構函式是否有違C++標準或有什麼隱晦，我在其他很多有名的記憶體池(包括SGI STL alloc)實現上看到都是用的placement new，而不是手動呼叫建構函式。

三 operator new 過載：

前面簡單提到過 A* p = new A；所發生的事情：先呼叫operator new，如果類A過載了operator new，那麼就使用該過載版本，否則使用全域性版本::operatro new(size_t size)。那麼類中可以過載operator new的哪些版本？全域性operator new可以過載嗎？全域性和類中過載分別會在什麼時機呼叫？

1.在類中過載 operator new

上面提到的throwing(1)和nothrow(2)的operator new是可以被過載的，比如：

#include <iostream>  
class A  
{  
public:  
    A()  
    {  
        std::cout<<"call A constructor"<<std::endl;  
    }  

    ~A()  
    {  
        std::cout<<"call A destructor"<<std::endl;  
    }  
    void* operator new(size_t size)  
    {  
        std::cout<<"call A::operator new"<<std::endl;  
        return malloc(size);  
    }  

    void* operator new(size_t size, const std::nothrow_t& nothrow_value)  
    {  
        std::cout<<"call A::operator new nothrow"<<std::endl;  
        return malloc(size);  
    }  
};  
int _tmain(int argc, _TCHAR* argv[])  
{  
    A* p1 = new A;  
    delete p1;  

    A* p2 = new(std::nothrow) A;  
    delete p2;  

    system("pause");  
    return 0;  
}

如果類A中沒有對operator new的過載，那麼new A和new(std::nothrow) A;都將會使用全域性operator new(size_t size)。可將A中兩個operator new註釋掉，並且在A外新增一個全域性operator new過載：

void* ::operator new(size_t size)  
{  
    std::cout<<"call global operator new"<<std::endl;  
    return malloc(size);  
}

程式輸出：

注意，這裡的過載遵循作用域覆蓋原則，即在裡向外尋找operator new的過載時，只要找到operator new()函式就不再向外查詢，如果引數符合則通過，如果引數不符合則報錯，而不管全域性是否還有相匹配的函式原型。比如如果這裡只將A中operator new(size_t, const std::nothrow_t&)刪除掉，就會報錯：

error C2660: “A::operator new”: 函式不接受 2 個引數。

至於placement new，它本身就是operator new的一個過載，不需也儘量不要對它進行改寫，因為它一般是搭配 new(p) A(); 工作的，它的職責只需簡單返回指標。

對operator new的過載還可以新增自定義引數，如在類A中新增

void* operator new(size_t size, int x, int y, int z)  
{  
    std::cout<<"X="<<x<<"  Y="<<y<<" Z="<<z<<std::endl;  
    return malloc(size);  
}

這種過載看起來沒有什麼大作用，因為它operator new需要完成的任務只是分配記憶體，但是通過對這類過載的巧妙應用，可以讓它在動態分配記憶體除錯和檢測中大展身手。這將在後面operator new過載運用技巧中，展現。

2.過載全域性 operator new

全域性operator new的過載和在類中過載並無太大區別，當new A;時，如果類A中沒有過載operator new，那麼將呼叫全域性operator new函式，如果沒有過載全域性operator new，最後會呼叫預設的全域性operator new。

3.類中operator new和全域性 operator new 的呼叫時機

前面已經提到了在new時的呼叫順序，但是這裡提出來的原因是還存在一個全域性的new運算子，也就是::new，這個運算子會直接呼叫全域性operator new，並且也會呼叫建構函式。這可能讓人很犯迷糊，只做瞭解即可。這裡提到的呼叫時機都是指通過new運算子呼叫，沒有討論其他情況，比如主動呼叫。

四 operator new運用技巧和一些例項探索

1.operator new 過載運用於除錯：

前面提到如何operator new的過載是可以有自定義引數的，那麼我們如何利用自定義引數獲取更多的資訊呢，這裡一個很有用的做法就是給operator new新增兩個引數:char* file, int line,這兩個引數記錄new運算子的位置，然後再在new時將檔名和行號傳入，這樣我們就能在分配記憶體失敗時給出提示：輸出檔名和行號。

那麼如何獲取當前語句所在檔名和行號呢，windows提供兩個巨集：__FILE__和__LINE__。利用它們可以直接獲取到檔名和行號，也就是 new(__FILE__, __LINE__) 由於這些都是不變的，因此可以再定義一個巨集：#define new new(__FILE__, __LINE__)。這樣我們就只需要定義這個巨集，然後過載operator new即可。

原始碼如下，這裡只是簡單輸出new的檔名和行號。

//A.h  
class A  
{  
public:  
    A()  
    {  
        std::cout<<"call A constructor"<<std::endl;  
    }  

    ~A()  
    {  
        std::cout<<"call A destructor"<<std::endl;  
    }  

    void* operator new(size_t size, const char* file, int line)  
    {  
        std::cout<<"call A::operator new on file:"<<file<<"  line:"<<line<<std::endl;  
        return malloc(size);  
        return NULL;  
    }  

};  
//Test.cpp  
#include <iostream>  
#include "A.h"  
#define new new(__FILE__, __LINE__)  

int _tmain(int argc, _TCHAR* argv[])  
{  
    A* p1 = new A;  
    delete p1;  

    A* p2 = new A;  
    delete p2;  

    system("pause");  
    return 0;  
}

輸出：

注意：需要將類的宣告實現與new的使用隔離開來。並且將類標頭檔案放在巨集定義之前。否則在類A中的operator new過載中的new會被巨集替換，整個函式就變成了： void* operator new(__FILE__, __LINE__)(size_t size, char* file, int line)
編譯器自然會報錯。

2.記憶體池優化

operator new的另一個大用處就是記憶體池優化，記憶體池的一個常見策略就是分配一次性分配一塊大的記憶體作為記憶體池(buffer或pool)，然後重複利用該記憶體塊，每次分配都從記憶體池中取出，釋放則將記憶體塊放回記憶體池。在我們客戶端呼叫的是new運算子，我們可以改寫operator new函式，讓它從記憶體池中取出(當記憶體池不夠時，再從系統堆中一次性分配一塊大的)，至於構造和析構則在取出的記憶體上進行，然後再過載operator delete，它將記憶體塊放回記憶體池。關於記憶體池和operator new在參考文獻中有一篇很好的文章。這裡就不累述了。

3.STL中的 new

在SGI STL原始碼中,defalloc.h和stl_construct.h中提供了最簡單的空間配置器(allocator)封裝，見《STL原始碼剖析》P48。它將物件的空間分配和構造分離開來，雖然在defalloc.h中僅僅是對::operator new和::operator delete的一層封裝，但是它仍然給STL容器提供了更加靈活的介面

SGI STL真正使用的並不是defalloc.h中的分配器，而是stl_alloc.h中的SGI精心打造的”雙層級配置器”，它將記憶體池技術演繹得淋漓盡致，值得細細琢磨。順便提一下，在stl_alloc.h中並沒有使用::operator new/delete 而直接使用malloc和free。具體緣由均可參見《STL原始碼剖析》。

五 delete 的使用

delete的使用基本和new一致，包括operator delete的過載方式這些都相似，只不過它的引數是void*，返回值為void。但是有一點需要注意，operator delete的自定義引數過載並不能手動呼叫。比如

void* operator new(size_t size, int x)  
{  
    cout<<" x = "<<x<<endl;  
    return malloc(size);      
}  
void operator delete(void* p, int x)  
{  
    cout<<" x = "<<x<<endl;  
    free(p);  
}

如下呼叫是無法通過的：

A* p = new(3) A;//Ok
delete(3) p;//error C2541: “delete”: 不能刪除不是指標的物件

那麼過載operator delete有什麼作用？如何呼叫？事實上以上自定義引數operator delete 只在一種情況下被呼叫：當new運算子丟擲異常時。

可以這樣理解，只有在new運算子中，編譯器才知道你呼叫的operator new形式，然後它會呼叫對應的operator delete。一旦出了new運算子，編譯器對於你自定義的new將一無所知，因此它只會按照你指定的delete運算子形式來呼叫operator delete，而至於為什麼不能指定呼叫自定義delete(也就是隻能老老實實delete p)，這個就不知道了。

細心觀察的話，上面operator new用於除錯的例子程式碼中，由於我們沒有給出operator new對應的operator delete。在VS2008下會有如下警告：

warning C4291: “void *A::operator new(size_t,const char *,int)”: 未找到匹配的刪除運算子；如果初始化引發異常，則不會釋放記憶體

六 關於 new 和記憶體分配的其他

1.set_new_handler

還有一些零散的東西沒有介紹到，比如set_new_handler可以在malloc(需要呼叫set_new_mode(1))或operator new記憶體分配失敗時指定一個入口函式new_handler，這個函式完成自定義處理(繼續嘗試分配，丟擲異常，或終止程式)，如果new_handler返回，那麼系統將繼續嘗試分配記憶體，如果失敗，將繼續重複呼叫它，直到記憶體分配完畢或new_handler不再返回(丟擲異常，終止)。下面這段程式完成這個測試：

#include <iostream>  
#include <new.h>// 使用_set_new_mode和set_new_handler  
void nomem_handler()  
{  
    std::cout<<"call nomem_handler"<<std::endl;  
}  
int main()  
{  
    _set_new_mode(1);  //使new_handler有效  
    set_new_handler(nomem_handler);//指定入口函式 函式原型void f();  
    std::cout<<"try to alloc 2GB memory...."<<std::endl;  
    char* a = (char*)malloc(2*1024*1024*1024);  
    if(a)  
        std::cout<<"ok...I got it"<<std::endl;  
    free(a);  
    system("pause");  
}

程式執行後會一直輸出call nomem_handler 因為函式裡面只是簡單輸出，返回，系統嘗試分配失敗後，呼叫nomem_handler函式，由於該函式並沒有起到實際作用(讓可分配記憶體增大)，因此返回後系統再次嘗試分配失敗，再呼叫nomem_handler，迴圈下去。

在SGI STL中的也有個仿new_handler函式:oom_malloc

2.new 分配陣列

A* p = new A[3];中，會直接呼叫全域性的operator new[](size_t size)，而不管A中是否有operator new[]的過載。而delete[]p卻會優先呼叫A::operator delete[](void*)(如果A中有過載)。另外還要注意的是，在operator new[](size_t size)中傳入的並不是sizeof(A)*3。而要在物件陣列的大小上加上一個額外資料，用於編譯器區分物件陣列指標和物件指標以及物件陣列大小。在VS2008下這個額外資料佔4個位元組，一個int大小。測試程式碼如下

//A.h  
class A  
{  
public:  
    A()  
    {  
        std::cout<<"call A constructor"<<std::endl;  
    }  

    ~A()  
    {  
        std::cout<<"call A destructor"<<std::endl;  
    }  

    void* operator new(size_t size)  
    {  
        std::cout<<"call A::operator new[] size:"<<size<<std::endl;  
        return malloc(size);  
    }  
    void operator delete[](void* p)  
    {  
        std::cout<<"call A::operator delete[]"<<std::endl;  
        free(p);  
    }   
    void operator delete(void* p)  
    {  
        free(p);  
    }   
};
//Test.cpp  
#include <iostream>  
#include "A.h"  

void* operator new[](size_t size)  
{  
    std::cout<<"call global new[] size: "<<size<<std::endl;  
    return malloc(size);  
}  

void operator delete[](void* p)  
{  
    std::cout<<"call global delete[] "<<std::endl;  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  
    std::cout<<"sizeof A "<<sizeof(A)<<std::endl;  
    A* p1 = new A[3];  
    delete []p1;  

    system("pause");  
    return 0;  
}

輸出：

簡單跟蹤了一下：

operator new[]返回的是0x005b668 而最後new運算子返回給p的是0x005b66c。也就是說p就是陣列的起始地址，這樣程式看到的記憶體就是線性的，不包括前面的額外資料。

在記憶體中，可以看到前面的四個位元組額外資料是0×00000003 也就是3，代表陣列元素個數。後面三個cd是堆在Debug中的預設值(中文的cdcd就是”屯”，棧的初始值為cc，0xcccc中文”燙”)。再後面的0xfdfdfdfd應該是堆塊的結束標誌，前面我有部落格專門跟蹤過。

注：其實在malloc原始碼中也有記憶體池的運用，而且也比較複雜。最近在參考dlmalloc版本和STL空間介面卡，真沒有想到一個記憶體分配能涉及這麼多的東西。

相關文章