重載new和delete
首先借用C++ Primer 5e的一個例子：
string *sp = new string("a value"); string *arr = new string[10];
這其實進行了以下三步操作：
new表達式調用一個名為operator new（或者operator new[]）的標准函數，分配一塊足夠大的，原始的，未命名的內存空間來存儲特定的類型或者對象的數組。編譯器運行相應的構造函數以構造這些對象，並且傳入初值。對象構造完畢后返回指向該對象的指針。
當我們進行下列的語句時：
delete sp; delete[]arr;
這段代碼也執行了以下兩個步驟：
對sp所指的對象或者arr所指的數組中的元素執行析構函數然后第二部調用operator delete或者(operator delete[])的標准庫來釋放掉內存空間。
應用程序可以在全局作用域定義operator new和operator delete函數，也可以把他們定義為成員函數。operator new和operator delete的查找滿足C++作用域的查找方式。
現在C++17版本的operator new可以有以下形式
replaceable allocation functions void* operator new ( std::size_t count ); void* operator new[]( std::size_t count ); void* operator new ( std::size_t count, std::align_val_t al);(since C++17) void* operator new[]( std::size_t count, std::align_val_t al);(since C++17) replaceable non-throwing allocation functions（nothrow版本表示承諾不拋出異常，分配內存失敗直接返回null，但是不保證構造函數不拋出異常，沒什么使用必要） void* operator new ( std::size_t count, const std::nothrow_t& tag); void* operator new[]( std::size_t count, const std::nothrow_t& tag); void* operator new ( std::size_t count, std::align_val_t al, const std::nothrow_t&);(since C++17) void* operator new[]( std::size_t count, std::align_val_t al, const std::nothrow_t&);(since C++17) non-allocating placement allocation functions（注意這兩個版本不能重定義, 也就是常見的placement new） void* operator new ( std::size_t count, void* ptr ); void* operator new[]( std::size_t count, void* ptr ); user-defined placement allocation functions void* operator new ( std::size_t count, user-defined-args... ); void* operator new[]( std::size_t count, user-defined-args... ); void* operator new ( std::size_t count, std::align_val_t al, user-defined-args... ); (since C++17) void* operator new[]( std::size_t count, std::align_val_t al, user-defined-args... );(since C++17) class-specific allocation functions void* T::operator new ( std::size_t count ); void* T::operator new[]( std::size_t count ); void* T::operator new ( std::size_t count, std::align_val_t al );(since C++17) void* T::operator new[]( std::size_t count, std::align_val_t al );(since C++17) class-specific placement allocation functions void* T::operator new ( std::size_t count, user-defined-args... ); void* T::operator new[]( std::size_t count, user-defined-args... ); void* T::operator new ( std::size_t count, std::align_val_t al, user-defined-args... );(since C++17) void* T::operator new[]( std::size_t count, std::align_val_t al, user-defined-args... );(since C++17)
現在C++17版本的operator delete可以存在以下版本：
replaceable usual deallocation functions void operator delete ( void* ptr ); void operator delete[]( void* ptr ); void operator delete ( void* ptr, std::align_val_t al );(since C++17) void operator delete[]( void* ptr, std::align_val_t al );(since C++17) void operator delete ( void* ptr, std::size_t sz );(since C++14) void operator delete[]( void* ptr, std::size_t sz );(since C++14) void operator delete ( void* ptr, std::size_t sz, std::align_val_t al );(since C++17) void operator delete[]( void* ptr, std::size_t sz, std::align_val_t al );(since C++17)
replaceable placement deallocation functions（同new，只能保證operator delete不拋出異常，但是不能保證析構不拋出異常） void operator delete ( void* ptr, const std::nothrow_t& tag ); void operator delete[]( void* ptr, const std::nothrow_t& tag ); void operator delete ( void* ptr, std::align_val_t al, const std::nothrow_t& tag );(since C++17) void operator delete[]( void* ptr, std::align_val_t al, const std::nothrow_t& tag );(since C++17)
non-allocating placement deallocation functions（也就是傳統意義上的placement delete） void operator delete ( void* ptr, void* place ); void operator delete[]( void* ptr, void* place );
user-defined placement deallocation functions void operator delete ( void* ptr, args... ); void operator delete[]( void* ptr, args... );
class-specific usual deallocation functions void T::operator delete ( void* ptr ); void T::operator delete[]( void* ptr ); void T::operator delete ( void* ptr, std::align_val_t al );(since C++17) void T::operator delete[]( void* ptr, std::align_val_t al );(since C++17) void T::operator delete ( void* ptr, std::size_t sz ); void T::operator delete[]( void* ptr, std::size_t sz ); void T::operator delete ( void* ptr, std::size_t sz, std::align_val_t al );(since C++17) void T::operator delete[]( void* ptr, std::size_t sz, std::align_val_t al );(since C++17)
class-specific placement deallocation functions void T::operator delete ( void* ptr, args... ); void T::operator delete[]( void* ptr, args... );
當我們重載operator new和operator delete的時候，一定不能改變其分配內存/回收內存的本質。
placement new與placement delete
上面有四個版本的operator new和operator delete
non-allocating placement allocation functions（注意這兩個版本不能重定義, 也就是常見的placement new） void* operator new ( std::size_t count, void* ptr ); void* operator new[]( std::size_t count, void* ptr ); non-allocating placement deallocation functions（也就是傳統意義上的placement delete） void operator delete ( void* ptr, void* place ); void operator delete[]( void* ptr, void* place );
就是傳統的placement new和placement delete，不允許重新定義，特點就是額外參數多了一個指針，不分配內存，專門對對象進行構造。使用形式可以像下面那樣：
new (place_address) type new (place_address) type (initializers) new (place_address) type [size] new (place_address) type [size]{ braced initializer list }
使用placement我們可以更方便控制內存分配（比如要做內存池），比如SGI STL中的construct就運用了這種方法：（實際上在C++11以后consturct就規定可以不是默認構造了，可以有其他構造方法。）
template <class _T1> inline void _Construct(_T1* __p) { new ((void*) __p) _T1(); } template <class _Tp> inline void _Destroy(_Tp* __pointer) { __pointer->~_Tp(); }
當我們使用了我們自定義的placement new（注意一般來說，我們說的placement new就是上面那個不分配內存的那個版本，其他對operator new進行重載的版本，也可以稱為placement new（有額外參數）,placement delete同理）時，要注意一定要同時定義相同形式的placement delete，否則會發生潛在的內存泄漏。
比如現在我們在某個類中定義了我們自己的placement new和placement delete
class Widget { public: Widget(int i) :m_haha(i) { throw std::exception(); } static void *operator new(std::size_t size, std::ostream& logStream); static void operator delete(void *pMemory) { ::operator delete(pMemory); } static void operator delete(void *pMemory, std::ostream& logStream); private: int m_haha; }; void *Widget::operator new(std::size_t size, std::ostream& logStream) { cout << "Hello World" << std::endl; while (true) { auto p = malloc(size); if (p) return p; auto h = get_new_handler(); if (!h) h(); else
throw std::bad_alloc(); } } void Widget::operator delete(void *pMemory, std::ostream& logStream) { cout << "Hello World delete" << std::endl; ::delete pMemory; } int main() { try { Widget *k = new (std::cout) Widget(1); delete k; } catch (const std::exception&) { } return 0; }
這里可能會讓人產生一個疑問，為什么我們不是調用placement delete來刪除對象呢？這里需要注意的是，placement delete只會在對應形式（也就是除了開頭的第一個，其他參數一模一樣）placement new構造對象發生異常以后才會被調用（也就是有placement delete function，但是沒有 placement delete expression，我們不能手動調用placement delete）。
上述代碼的運行結果：
如果我們要定義一個類型公有繼承某個重載了operator new 和operator delete的類型，而我們又想在新的類型里面添加新的operator new 和operator delete，則可以這么寫：
class DerivedWidget : public Widget { public: using Widget::operator delete; using Widget::operator new; static void *operator new(std::size_t size, const std::nothrow_t nt); static void operator delete(void *pMemory, const std::nothrow_t nt); };
new_handler
當operator new無法申請到所需內存時，我們可以調用所謂的new_handler，在標准庫中有以下內容：
typedef void (__CLRCALL_PURE_OR_CDECL * new_handler) (); #endif /* !defined(_INC_NEW) || !defined(_MSC_EXTENSIONS) */
// FUNCTION AND OBJECT DECLARATIONS
_CRTIMP2 new_handler __cdecl set_new_handler(_In_opt_ new_handler) _THROW0(); // establish alternate new handler
_CRTIMP2 new_handler __cdecl get_new_handler() _THROW0(); // get current new handler
_STD_END
其中get_new_handler()是C++ 11新增的，在沒有這個方法之前，我們想要獲得全局的hanlder只能用set一個0的handler（這樣會獲得當前的hanlder），然后再把獲得的handler再set回去的別扭手段。
由於operator new的實現要求是：當存在new_handler，就會不斷調用，直到找到夠用的內存為止。
一個設計良好的new_handler必須做以下事情：
讓更多內存可被使用安裝另一個new-handler（如果當前的new-handler無法獲取更多的內存，可以用另一個代替）卸載new-handler拋出bad_alloc（或者派生自此異常的其他異常），讓異常傳播到其他地方不返回，調用abort或者exit
effective C++ 3e有一個非常好的實踐例子，以CRTR模式封裝new_handler的技術（curiously recurring template pattern; CPTR）
template<typename T>
class NewHandlerSupport { public: NewHandlerSupport() = default; explicit NewHandlerSupport(std::new_handler h):_handler(h) { } ~NewHandlerSupport() { std::set_new_handler(_handler); } static void *operator new(std::size_t size) { ::operator new(size); } static void *operator new(std::size_t size, std::ostream& logStream); static void operator delete(void *pMemory) { ::operator delete(pMemory); } static void operator delete(void *pMemory, std::ostream& logStream); static std::new_handler set_new_handler(std::new_handler p)noexcept; private: std::new_handler _handler;//拿來臨時替換的
static std::new_handler _currnentHandler; NewHandlerSupport(NewHandlerSupport &&) = default; NewHandlerSupport(const NewHandlerSupport &) = delete; NewHandlerSupport& operator=(const NewHandlerSupport &) = delete; }; template<typename T> std::new_handler NewHandlerSupport<T>::set_new_handler(std::new_handler p)noexcept { std::new_handler oldHandler = _currnentHandler; _currnentHandler = p; return oldHandler; } template<typename T>
void NewHandlerSupport<T>::operator delete(void *pMemory, std::ostream& logStream) { cout << "Hello World delete" << std::endl; ::delete pMemory; } template<typename T>
void * NewHandlerSupport<T>::operator new(std::size_t size, std::ostream& logStream) { NewHandlerSupport h(std::set_new_handler(_currnentHandler)); cout << "Hello World" << std::endl; return ::operator new(size); } template<typename T>std::new_handler NewHandlerSupport<T>::_currnentHandler = 0; class Widget : public NewHandlerSupport<Widget> { public: Widget(int i) :m_haha(i) { } private: int m_haha; };
這樣就可以一個類型一個不同的new_handler了，而且不同類型的new_handler只會影響到自身的operator new。
使用時可以這樣：
Widget::set_new_handler(error); Widget *k = new (std::cout) Widget(1); delete k;
new與malloc在內存布局上的區別
我們經常說C++的內存管理(new和delete)和C的(malloc和free)最大的不同是，C++分配的內存是在自由存儲區，而C則是在堆區，至於堆區就是現代操作系統給進程分配的內存空間的一部分，看下面的圖。
實際上在VS編譯器上，缺省的operator new 反匯編出來是下面的樣子：
void* __CRTDECL operator new(size_t const size) { 00007FF74DC58630 mov qword ptr [rsp+8],rcx 00007FF74DC58635 sub rsp,38h for (;;) { if (void* const block = malloc(size)) 00007FF74DC58639 mov rcx,qword ptr [size] 00007FF74DC5863E call malloc (07FF74DC513FCh) 00007FF74DC58643 mov qword ptr [rsp+20h],rax 00007FF74DC58648 cmp qword ptr [rsp+20h],0 00007FF74DC5864E je operator new+27h (07FF74DC58657h) { return block; 00007FF74DC58650 mov rax,qword ptr [rsp+20h] 00007FF74DC58655 jmp operator new+4Bh (07FF74DC5867Bh) } if (_callnewh(size) == 0) 00007FF74DC58657 mov rcx,qword ptr [size] 00007FF74DC5865C call _callnewh (07FF74DC516B8h) 00007FF74DC58661 test eax,eax 00007FF74DC58663 jne operator new+49h (07FF74DC58679h) { if (size == SIZE_MAX) 00007FF74DC58665 cmp qword ptr [size],0FFFFFFFFFFFFFFFFh 00007FF74DC5866B jne operator new+44h (07FF74DC58674h) { __scrt_throw_std_bad_array_new_length(); 00007FF74DC5866D call __scrt_throw_std_bad_array_new_length (07FF74DC51604h) } else 00007FF74DC58672 jmp operator new+49h (07FF74DC58679h) { __scrt_throw_std_bad_alloc(); 00007FF74DC58674 call __scrt_throw_std_bad_alloc (07FF74DC5120Dh) } } // The new handler was successful; try to allocate again...
} 00007FF74DC58679 jmp operator new+9h (07FF74DC58639h) }
同樣，全局delete反匯編出來是：
void __CRTDECL operator delete(void* const block) noexcept { 00007FF74DC586A0 mov qword ptr [rsp+8],rcx 00007FF74DC586A5 sub rsp,28h #ifdef _DEBUG _free_dbg(block, _UNKNOWN_BLOCK); 00007FF74DC586A9 mov edx,0FFFFFFFFh 00007FF74DC586AE mov rcx,qword ptr [block] 00007FF74DC586B3 call _free_dbg (07FF74DC5119Ah) #else
free(block); #endif }
我們可以看到實際上在PJ版本的STL（也就是VS自帶的那個），new缺省的實現方式本質上是通過malloc的，這個時候，C++的自由存儲區的概念和C的堆的概念是沒有區別的，但是如果我們通過重載operator new 的方式把內存分配在一些全局變量上，那么這些內存就不屬於堆區了，而是在data segment。也就是說，C++的自由存儲區可以包括堆區，也可以包括其他區域。
同時我們也可以看到，當分配內存失敗時，C++的處理方式也和C不一樣，我們知道，在C當malloc失敗的時候，會直接返回一個NULL，但是在C++不是的，如果在沒有指定new_handler的情況下，會直接拋出bad_alloc異常，而不是返回NULL，如果指定了new_handler，那么會調用handler進行處理，再進行分配，直到分配成功為止。
如果使用new進行內存分配，那么C++不僅會分配內存，而且還會進行placement new構造對象，而malloc不會的。同理，C++的delete也會對對象進行析構，而free不會。在申請數組時，在C++中，一定要進行delete[]進行內存的回收，在C++中用new分配了一個數組，會添加其他信息（比如長度），如果不使用delete[]形式刪除數組，那么會導致內存不會被完全回收導致內存泄漏，而且對象也不會被正確析構。
allocator類
在C++11以后，我們可以使用std::allocator來進行像內存池的操作，可以像下面這樣用：
std::allocator<string> alloc; auto p = alloc.allocate(10); alloc.construct(p, "fuck");
construct是構造一個對象，destory對對象進行析構，deallocate可以我們通過allocate分配的內存。這樣我們就可以很方便地構造內存池了。
allocator在C++17已經被棄用，轉而應該使用std::allocator_traits。std::allocator_traits中有allocator內有的東西，但是所有方法都變成了靜態的，這種設計的思路是：因為allocator的任務只是allocate和deallocate，而construct應該與allocator無關。這樣變更以后allocator的功能更明顯了。
Reference: