定制自己的new和delete:operator new 和 operator delete
2018-03-04 17:08
405 查看
new和delete不同用法
基本用法
int * aptr = new int(10);delete aptr, aptr = nullptr;上面的代码是我们最基本也是最常见的使用new和delete的方式,当编译器运行int * aptr = new int(10); 这行代码时,其实是分为两个步骤来执行,第一步,调用operator new(size_t size) 分配内存;第二步在分配的内存上调用placement new(void * ptr) T(); “定位放置 new”,就是把对象构建在指定的ptr指向的内存上,换句话就是在指定的内存上调用构造函数。
概念区分
new operator 和 delete operator :new 和 delete 操作符(关键字),无法重载operator new 和 operator delete:两个函数用来服务于 new 和 delete 操作符,以及对应的 operator new [] , operator delete [] 对应于 new [] 和 delete []相关的数组操作;这两个函数是可以被重载的,一般有全局默认的函数,自己也可以定义自己的,在定义C++类的时候也可以为某个class定制对应的 operator new 和 operator delete
全局的operator new 和 operator delete函数
全局默认operator new 函数:void * operator new(std::size_t count) throw(std::bad_alloc); //normal new void * operator new(std::size_t count, void *ptr)throw(); //placement new void * operator new(std::size_t count, const std::nothrow_t&)throw();//nothrow new, 为了兼容以前的版本我们可以根据自己的意愿来重载 不同版本的operator new 函数来覆盖掉全局的函数,对于申明的类,可以在类中申明对应的
static void * operator new(size_t size);来为该类定制自己的operator
operator new的不同重载办法
#include <iostream> #include <new> #include <cstring> #include <cstdlib> using namespace std; /* 首先自己定义operator new函数,来替代编译器全局默认的operator函数 */ void * operator new(size_t size){ cout<<"global Override operator new"<<endl; void * ptr = malloc(size); //自己调用malloc来分配内存 return ptr; //下面这句话会引起递归的调用,重载operator new之后,::operator new就等于调用自己 //return ::operator new(size); } //重载版本的operator new,该函数默认的是调用 上面的operator new函数 void * operator new(size_t size, int flag){ cout<<"global Override operator new: "<<flag<<endl; return (::operator new(size)); } //覆盖掉全局的operator delete 函数 void operator delete (void * ptr){ cout<<"global Override operator delete"<<endl; free(ptr); ptr = nullptr; } /* 重载版本的operator delete,该函数主要的用途是在构造函数执行不成功的时候,调用与new 函数对应的 delete来释放,稍后会有对应的列子来介绍,在这个例子中该函数暂时没用 */ void operator delete (void * ptr, int flag){ cout<<"Override operator delete: "<<flag<<endl; ::operator delete(ptr); ptr = nullptr; } int main(){ int * ptr = new int(10); /* delete ptr; 调用的就是 void operator delete(void * ptr); 而与new 匹配的delete 不是自己调用的,而是在new申请,成功却在构造函数时候出错,new operator自己根据operator new 来寻找 对应的operator delete 来调用,稍后介绍。 */ delete ptr; cout<<endl<<"*********************"<<endl<<endl; ptr = new(20) int(10); delete ptr; return 0; }上面的程序的输入如下面:
从上面的结果可以看出,new int(10);直接先调用 operator new(size_t size); 由于int没有构造函数,在那块内存上调用int的构造函数; 在delete ptr; 的时间直接调用 operator delete(void * ptr);这个函数当
new(20) int(10);的时候,则调用重载版本的 operator new(size_t size, int flag); 而该函数有调用了 operator new(size_t size); 函数,释放的时候delete ptr;还是直接只调用operator delete(void * ptr);(注:这里初步提出为啥不调用operator delete(void * ptr, int flag); 这个函数来释放ptr ???因为它的用途不在这,而在于下面将要讲的。
针对类定制版本的operator new 和 operator delete
#include <iostream> #include <new> #include <cstring> #include <cstdlib> using namespace std; //下面的operator new 和 operator delete 和上面的代码一样,替代默认全局函数 void * operator new(size_t size){ cout<<"global Override operator new"<<endl; void * ptr = malloc(size); return ptr; } void * operator new(size_t size, int flag){ cout<<"global Override operator new: "<<flag<<endl; return (::operator new(size)); } void operator delete (void * ptr){ cout<<"global Override operator delete"<<endl; free(ptr); ptr = nullptr; } //这次主要体现该函数的用法********************* void operator delete (void * ptr, int flag){ cout<<"Override operator delete: "<<flag<<endl; ::operator delete(ptr); ptr = nullptr; } class Base{ public: Base(){ cout<<"Base construct"<<endl; throw 2; } /* 类中定制的operator new会覆盖全局的函数,但可以通过简单的调用全局的函数来实现调用 */ static void * operator new(size_t size){ cout<<"operator new of Base"<<endl; return ::operator new(size); //调用全局的operator new } static void * operator new(size_t size, int flag){ cout<<"Override operator new of Base: "<<flag<<endl; return operator new(size); } static void operator delete(void * ptr){ cout<<"Operator delete of Base"<<endl; ::operator delete(ptr); } static void operator delete(void * ptr, int flag){ cout<<"Override operator delete of Base: "<<flag<<endl; operator delete(ptr); } int x; int y ; }; int main(){ try{ Base * bptr = new(20) Base; } catch(...){ cout<<"catch a exception"<<endl; } return 0; }上面的函数,在Base的构造函数中,抛出一个异常(忽略什么异常,主要用来模拟),直接上运行结果图:
如上图所示的运行结果,
new(20) Base首先调用类中定制的 operator new(size_t size, int flag); 然后在调用 operator new(size_t size); 在调用全局的 operator new(size_t size);申请完内存之后,在调用类的构造函数,此时会抛出异常,这个时候,由于调用的 operator new(size_t size, int flag);函数来申请内存,但构造函数失败了,此时 new - operator (new 关键字,区分operator new)会调用和 operator new 相同参数的operator delete函数来释放已经申请的内存,因此operator delete(void ptr, int flag) ,在调用operator delete(void ptr); 在调用全局的operator delete(void * ptr);若是不给Base类重载
static void operator delete(void * ptr, int flag);这个函数,结果则如下图:
这个例子就说明,不定制对应的operator delete(), 则绝不会调用默认的operator delete函数来释放内存,这里就会导致内存泄露。因此在为某个class 定制 operator new函数的时候,如果重载了不同参数的operator new,应该定制对应版本的operator delete(); 这里对应版本是参数是对应的;(这里也就是 operator delete(void * ptr, int flag);的主要用途,当构造函数异常的时候,它负责清理已申请的内存)。
其他知识点
std::new_handler
这是一个回调函数,主要用于 operator new申请内存不成功的时候调用,感觉可以类比于,信号处理函数,operator new申请不成功(接受到某个信号),调用该handler(触发信号处理函数)。最主要的用途就是通过set_new_handler()来更换不同的处理函数。类继承中的operator new函数处理
假如我们为一个Base类,定制了自己的operator new,则Base的派生类Derived,肯定也继承了该函数,当Derived * dptr = new Derived;的时候,肯定就调用了Base::operator new()函数,而派生类的大小一般和基类大小是不同的,因此这里需要额外注意,不能调用基类的operator new();对于这点解决办法,1,在Derived 中重写operator new函数;2,在Base类的operator new函数中添加一句话如下图:
void * operator new(size_t size ){ if(size != sizeof(Base)) return ::operator new(size); /*其他交给Base::operator new处理*/ }
operator new[] 和 operator delete[]
这两个和operator new operator delete 用处基本一致,只是针对数组的,这里就不多讲。额外的补充(可能有点绕口, 下面是纯个人观点,有哪里不对,请大家指出,共同学习)
void operator new(size_t size, void * ptr) noexcept;这是C++11官方定义的placement new的格式,该函数的主要作用是把把size大小的结构体放置在ptr指向的内存上,也就是在ptr指向的内存调用构造函数。先说一个上面的正确的使用方法:
#include <iostream> #include <new> #include <cstring> using namespace std; class Base{ public: Base():x(-1), y(-1){ cout<<"Construct of Base and my addr = : ["<<this<<"]."<<endl; } static void * operator new(size_t size, void * ptr){ cout<<"My placement new."<<endl; return ::operator new(size, ptr); } //Base类只占用两个int型的大小 int x; int y; }; static int arr[20]; //栈上的空间,用来分配Base int main(){ memset(arr, 0, sizeof(arr)); cout<<"arr addr = ["<<arr<<"]."<<endl; Base * ptr = new(arr) Base(); ptr = nullptr; cout<<arr[0]<<" "<<arr[1]<<endl; return 0; }
arr数组前两个变成 -1。
上面的代码,ptr没有直接delete,而是直接赋值为nullptr,为什么这么做,因为调用delete ptr; 会直接错误,ptr指向的是栈地址空间,而delete释放的是堆上的空间,因此会出错。另一种情况:假设arr就是堆上的地址空间,此时调用delete ptr,肯定能成功,但是这里会有两种风险,一种是,delete ptr;释放一次内存,delete arr;第二次释放内存,错误;另一种,假设ptr 是占用的arr指向的内存的中间部分,你delete ptr;归还给系统,但是 arr 这个时候该怎么处理,这种情况应该是坚决杜绝的,(具体情况我没测试,原理上肯定是杜绝这种情况出现:只归还堆上连续空间的中间部分。)上面说了那么多,其实想表达一个意思,当调用
void * operator new(size_t size, void * ptr);无论其是否成功,或者接下来的构造函数是否成功,ptr内存都不应该释放,应该交由,ptr诞生的地方来管理。因此对于该函数一般不需要申明对应的 operator delete() 来防止构造函数未成功时候来释放内存(和“声明placement new 的时候一定要声明对应的 placement delete函数这个理论有点相反”)。要是强行为
void * operator new(size_t size, void * ptr);声明对应的operator delete ,方式如下:
void operator delete(void * ptr, void * ptr2);代码如下:
#include <iostream> #include <new> #include <cstring> using namespace std; class Base{ public: Base():x(-1), y(-1){ cout<<"Construct of Base and my addr = : ["<<this<<"]."<<endl; throw 2; } static void * operator new(size_t size, void * ptr){ cout<<"My placement new."<<endl; return ::operator new(size, ptr); } /* 必须声明为 void * ptr1, void * ptr2 这种形式,声明为其他参数,和上面的 operator new不匹配 */ static void operator delete(void * ptr1, void * ptr2){ cout<<"My operator delete"<<endl; } int x; int y; }; int arr[20]; int main(){ try{ memset(arr, 0, sizeof(arr)); cout<<"arr addr = ["<<arr<<"]."<<endl; Base * ptr = new(arr) Base(); ptr = nullptr; cout<<arr[0]<<" "<<arr[1]<<endl; } catch(...){ cout<<"catch one exception."<<endl; } return 0; }
可以看出图中有 My operator delete 的显示,若把 operator delete参数改成其他的,则无法调用。看到有地方把
operator new(size_t size, int flag, ...);形式(也就是除了size_t 一个参数之外,还有自定义参数,也就是重载原来的
operator new(size_t size);都称为 placement new)我觉重载更直观。对于
void * operator new(size_t size, int flag, ../*自定义参数*/.. );与之对应的operator delete如下:
void operator delete(size_t size, int flag, ../*自定义参数*/..);也就是有上面的为啥,
operator delete(void * ptr1, void * ptr2);上面的内容主要参考自《Effective C++》,若哪里有理解不对,请大家多指出。
本文转自:
https://www.cnblogs.com/cly-blog/p/5984660.html
相关文章推荐
- 解析C++中的new、operator new、operator new[]和delete、operator delete、operator delete[](下)
- 解析C++中的new、operator new、operator new[]和delete、operator delete、operator delete[](上)
- 动态内存开辟C语言和C++,new与delete,malloc和free,operator new 和operator delete
- C++ 的 new 和 delete : new operator, operator new, placement new, delete operator, operator delete
- new 、delete运算符 、operator new 、operator delete 、malloc 、 free 函数
- 8.定制new和delete
- delete与delete[]的区别【C++ Primer 第4版 18.1.3 operator new函数和operator delete接口】
- 【effective c++读书笔记】【第8章】定制new和delete(1)
- 《Effective C++》第8章 定制new和delete-读书笔记
- effective C++笔记之条款9、10:避免隐藏标准形式的new、如果写了operator new 就要同时写operator delete
- 《Effective C++ 3》08 定制new/delete和其他 条款:49-55
- effective C++读书笔记八 —— 定制new 和delete
- 第八章 定制new和delete
- 【C++】定制new和delete
- Effective C++ 8. 定制 new 和 delete
- Part8:定制new和delete
- C++中operator new 和 new operator小结以及对new 和 delete初步理解
- 定义自己的operator new和operator delete时注意点
- operator new之签名式new/delete(signature operator new/delete)
- 实现类的特定的set_new_handler,operator new ,operator delete