C++ 内存分配操做符new和delete详解

时间 2019-11-18

标签 c++ 内存分配 new delete 详解栏目 C&C++ 繁體版

原文原文链接

重载new和deletehtml

首先借用C++ Primer 5e的一个例子：express

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:

http://www.cnblogs.com/QG-whz/p/5060894.html

http://www.cnblogs.com/QG-whz/p/5140930.html