超碰人人爱,亚洲区在线,亚洲人人舔人人

new expression

new一個類型，會創建一個該類型的內存，然后調用構造函數，最后返回該內存的指針

注意：該操作是原子性的。

在vc6中的實現如下

void *operator new(size_t size, const std::nothrow_t &) _THROW0()
{
  void *p
  while((p = malloc(size)) == 0)
  {
      // 如果調用malloc失敗后會調用_callnewh
      // _callnewh含義是call new handler，簡單說就是用戶設定一個回調函數
      // 使用_set_new_handler來設置，通常是用戶自己控制釋放一些不用的內存
      _TRY_BEGIT
          if(_callnewh(size) == 0) break;
      _CATCH(std::bad_alloc) return (0);
      _CATCH_END
  }
  return (p);
}

delete expression

delete 一個指針，先調用析構函數，然后釋放內存

在vc6中的實現如下

void *operator delete(void *p) _THROW0()
{
  free(p);
}

new[]和new()

new[]是分配指針數組，new()是分配時直接初始化，這兩個很容易搞混，關鍵是編譯都能過，一定要注意。比如：

int *p = new[3]; // 是分配三個int*指針所組成的指針數組
int *q = new(3); // 是分配一個int堆內存，并初始化為3

new[]和delete[]

Complex *pca = new Complex[3];

調用三次Complex的構造函數，分配三個Complex對象

delete[] pca;

釋放內存。

如果這里的delete[]只寫寫成delete會怎么樣？好多人一定會說：會內存泄露。

其實正確的答案是不確定，具體需要看Complex類的內部有沒有堆內存

new[]后內存是怎么樣的呢？看下圖

一篇文章了解c++中的new和delete

關鍵是看圖中的cookie部分，存放了一些內存相關的數據，其中最關鍵的是在cookie中存放了分配內存的大小

再來看一下下面的代碼

string *psa = new string[3];
delete psa;

執行完該代碼后內存分配如下

一篇文章了解c++中的new和delete

由于string類的內部使用動態堆內存來保存字符串，new[]分配的內存的cookie只記錄了string類的信息，而類內部的動態堆內存信息由每個實例自行管理，不在new[]的cookie中。

前面說過，delete釋放內存的過程是先調用析構函數，再釋放內存。在本例中，如果使用delete[]來釋放內存，會依次調用每個實例的析構函數，每個析構函數會自行釋放自己內部的堆內存，然后在釋放new的內存塊。但是如果使用delete來釋放內存，只會是第一個實例調用一次析構函數，另外兩個實例不會調用，然后根據cookie中記錄的內存大小釋放有new分配的內存，另兩個實例中的堆內存就泄露了。

也就是說，對于上圖string的例子，如果使用delete直接釋放內存，泄露的是str2和str3箭頭右邊的白色區域所示的內存，而pas箭頭右邊的綠色區域是能夠正確釋放的（具體是調用的str1還是str3取決于編譯器的具體實現，理解意思即可）。

但是，這不意味著你可以在類內部沒有堆內存的情況下就可以毫無顧忌的使用delete來釋放new[]，這是編碼規范的問題，使用delete不一定有錯，但使用delete[]則是一定沒錯。

new的內存分布

下圖是vc6中new的內存布局

一篇文章了解c++中的new和delete

我們得到的是圖中0x00441c30這一部分的指針，但實際上內存管理的是圖中所有的一大塊內存，其中橘黃色部分只有在debug模式下才有。由于內存管理需要是16的倍數，如果不夠16的倍數，則添加一些數據湊到16的倍數，圖中藍色的pad部分就是添加的無用數據。圖中61h部分就是cookie，上下部分分別為上cookie和下cookie。由于本例使用的是int類型舉例，而int沒有析構不析構的，所以可以直接使用delete就能完整釋放整塊內存。這里這么寫是為了讓讀者加深理解，實際編碼的時候要加上[]，這里對比一下下圖

一篇文章了解c++中的new和delete

這張圖使用的類型是一個類，用new[]分配內存的時候，返回的指針和調試信息中間多出來一塊內存用來記錄實例的個數，就是圖中的3。這中情況，如果使用delete[]來釋放內存，會正確索引到實例的首地址進行釋放操作，如果使用delete來釋放內存，索引到的內存是記錄實例個數的整型數據位置，如果從這里開始按找該類的內存結構進行析構，肯定是會出問題的，整個內存結構都亂了。

這里有個地方需要注意，這里的delete和delete[]部分看起來和new[]和delete[]小結中介紹的有些矛盾，老師是怎么講的，由于是看的盜版網課，也沒辦法請教老師，具體是怎么情況我也不太清楚。猜測是因為不同編譯器具體實現時，3的位置不同，有的在前面，有的在后面，關鍵是看具體實現，在前面的情況就是矛盾的，在后面就沒事，關鍵是領會精神。

placement new

placement new 允許我們將對象構建于一個已經分配的內存當中

沒有所謂的placement delete，因為placement根本就沒有分配內存，它只是使用了一個已經分配好的內存，所以不需要配套的釋放操作，具體用法如下

#include <new>

// 分配內存
char *buf = new char[sizeof(Complex) * 3];

// 在分配好的內存上構造Complex
Complex *pc = new(buf)Complex(1, 2);

// 注意這里要釋放的指針
// 感覺如果直接釋放pc應該也沒錯
// 手上沒環境不能測試，以后有時間測一下
delete[] buf;

new失敗處理

在純C中使用malloc來分配內存，需要判斷一下返回的指針，如果返回一個空指針，則代表內存分配失敗。

到了c艸中，使用new來分配內存，則無法通過判斷空指針的方法判斷是否失敗。因為在c艸中，如果new失敗會拋出異常，代碼是走不到判斷空指針的語句的。new失敗正確處理方法有以下幾種

捕捉異常

try 
{
  int* p = new int[SIZE];
  // 其它代碼
} catch ( const bad_alloc& e ) 
{
  return -1;
}

據說古老的c++編譯器new失敗不會拋異常，而是和malloc一樣返回空指針，因為那時候c++還沒有異常機制，坊間流傳，也懶得考證，了解以下即可。順便吐槽一下，說c艸的異常是屎，這是對屎的侮辱，屎還能當肥料種地呢，c艸的異常除了搗亂沒任何鳥用。

禁用new的異常

int* p = new (std::nothrow) int; // 這樣如果 new 失敗了，就不會拋出異常，而是返回空指針

new-handler

文章開始介紹new源碼的時候提到過，new實現的時候會調用new-handler的回調函數，在new之前設置好回調函數即可。由于此方法太過麻煩，懶得研究，具體用法讀者自行查找相關資料。

重載

一篇文章了解c++中的new和delete

重載的時候，一般不重載全局的::operator new，因為全局的影響太大，一般只重載類自身的Foo::operator new。

重載一般在內存池中用的比較多，可以減少cookie

重載全局的::operator new

void *myAlloc(size_t size)
{ return malloc(size); }

void myFree(void *p)
{ free(p); }

// 下面代碼實現部分不重要，關鍵看接口的重載
// 它們不可以被聲明在一個namespace內
inline void *operator new(size_t size)
{ cout << "global new()\n"; return myAlloc(size); }

inline void *operator new[](size_t size)
{ cout << "global new[]()\n"; return myAlloc(size); }

inline void operator delete(void *p)
{ cout << "global delete()\n"; return myFree(p); }

inline void operator delete[](void *p)
{ cout << "global delete[]()\n"; return myFree(p); }

重載局部的Foo::operator new

class Foo
{
public:
  void *operator new(size_t);
  void operator delete(void*);
};

需要注意的是，重載局部的new和delete必須是static的，因為new調用時是內存對象創建過程當中，此時還沒有一個完整的內存對象，無法通過對象來調用一般的函數。由于必須是static的，不管寫不寫static，編譯器都會當成是static處理。

數組版本也是一樣的，只是都加了一個[]，這里就不再寫一次了

重載placement new

placement new的括號中不一定非要放指針，我們可以自己來定義放任意的東西。放指針的版本是標準庫中先寫好給我們用的，我們也可以通過重載placement new來自定義所放的數據，比如Foo *pf = new(300, 'c')Foo;。可以重載為多種參數形式，但多個重載的參數列形式不能重復，必須滿足普通函數重載的條件。其中第一個參數必須是size_t，用來傳遞類的大小，該參數類似于成員函數的this指針，在調用時自動傳遞，不需要顯示傳遞。比如在Foo *pf = new(300, 'c')Foo;中，其聲明形式為void *operator new(size_t, int, char);。如果內存不是外部申請好的，需要在placement new函數內部去申請內存。

重載new的時候應該對應重載一個相同形式的delete。但重載placement delete時需要注意，只有在placement new中產生異常，才會調用其對應的placement delete函數。c++這么設計的原因是，在調用placement new函數后，如果內存是由在placement new內申請的，在調用構造函數時如果發生了異常，可以在對應的在placement delete函數中將在placement new中申請的內存釋放掉。

如果沒有對應形式的delete，編譯器也不會報錯，編譯器會認為你放棄處理該形式的new中產生的異常（個別編譯器會給個警告）

class Foo
{
public:

  // 重載一個一般形式的operator new
  void *operator new(size_t);

  // 標準庫中placement new的重載形式
  void *operator new(size_t, void *);

  // Foo *pf = new(300, 'c')Foo;調用形式的重載方式
  void *operator new(size_t, int, char);

  // 隨便寫的一種重載形式
  void *operator new(size_t, size_t, char *, int);

  // 以下是對應的delete
  void *operator delete(void *, size_t);
  void *operator delete(void *, void *);
  void *operator delete(void *, int, char);
  void *operator delete(void *, size_t, char *, int);
};

std::string中就是一個很好的placement new重載，有興趣的朋友可以去看string的源碼

c++ new與malloc的10點差別表格：

特征	new/delete	malloc/free
分配內存的位置	自由存儲區	堆
內存分配失敗返回值	完整類型指針	void*
內存分配失敗返回值	默認拋出異常	返回NULL
分配內存的大小	由編譯器根據類型計算得出	必須顯式指定字節數
處理數組	有處理數組的new版本new[]	需要用戶計算數組的大小后進行內存分配
已分配內存的擴充	無法直觀地處理	使用realloc簡單完成
是否相互調用	可以，看具體的operator new/delete實現	不可調用new
分配內存時內存不足	客戶能夠指定處理函數或重新制定分配器	無法通過用戶代碼進行處理
函數重載	允許	不允許
構造函數與析構函數	調用	不調用