重载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: