969
Something More about "new" &"delete" in C++
一、不只是malloc和free
new和delete都是C++中最基本的词汇，每天的代码都反复的与他们打交道，对他们最基本的认识就是分配和释放内存，最开始我认为他们就是C++版的malloc和free，但是其实内有玄机，除了分配内存，还可以用他们实现什么？
二、new和delete的完整过程
2.1 new 的完整过程可以分为三步，拿A* a=new A(1)这句为例：
- 首先它将调用operator new(size_t size)，在内存中分配sizeof（A）这么大的内存，也就是参数size=sizeof（A）；
operator new(size_t size)的默认实现是：
void *ptr = (void *)malloc(size);
return ptr;
- 第二步调用operator new( size_t count, void * object)，这个函数会忽略第一个参数，在已经分配好的内存object上返回A需要的那篇内存
operator new( size_t count, void * object)的默认实现是
return object;
- 第三步调用A的构造函数产生A
前两个步骤其实是operator new的不同overwrite，可能开始不太容易理解第二步的意义，第二步好像什么都没做，为什么还要存在这种形式的operator new呢？其实是因为这些operator new都可以被程序访问，例如我们可以直接写出这样的代码完成new一样的操作：
void * raw=operator new(sizeof(A));
A* a=new(raw)A(1)
(当然调用operator new要include “new.h”，因为operator new不是c++原生的操作，定义在一个头文件中)
其中第一步是分配内存，第二步中的new(raw)部分就要调用operator new( size_t count, void * object）了，new(buffer)class(param)这种形式的new也被称为placement new，它的意思是在一个已经存在的内存上构造某个对象，operator new( size_t count, void * object)这个看似无意义的接口其实是为了这种写法而做的。
2.2 delete ，delete 的完整过程也可分为两步，拿 delete* a举例：
- 首先调用A的析构函数
- 然后调用operator delete( void *, void *) ，这个函数其实什么也没干，就是一个空的，它只是对operator new( size_t count, void * object)的呼应
- 调用operator delete( void *),它是对operator new(size_t size)的呼应，默认实现就是一个free（），用于标记内存被回收。
所以我们可以用下面代码替换delete a：
a.~A();
operator delete(raw);
2.3 上面是new和delete的完整过程，响应的还有new[]和delete[]的类似实现，这是分配与释放一个相连的多个实例：
void* operator new[](size_t size){
void *ptr = (void *)malloc(size);
return ptr;
}
void operator delete[](void* p){
free(p);
return;
}
下面两个是为了placement new[]和delete[]
void* operator new[](size_t size，void * object){
return object;
}
void operator delete[](void* p，void *p){
return;
}
所以一段传统的代码 A* a=new A[10] 和 delete[] a也可以通过这些operator new[]的调用来实现成如下：
void* raw=operator new(sizeof(A)*10+sizeof(int));
A* a=new(raw)A[10];
for(size_t i=0;i<10;i++){
fl2[i].~leon();
}
operator delete[](raw);
这里在分配内存的地方有个很特殊的地方，我想创建10个A，理应分配sizeof(A)*10大小的内存，但是对于operator new[](size_t size)的调用，必须多给他分配一个sizeof（int），写成上面的void* raw=operator new(sizeof(A)*10+sizeof(int));这是为什么呢？
原因在于这里是分配连续的N个内存，但是你必须让c++多用一个int来存储这个N，这个int可能是放在这片内存的首位。
如果不多分配这个空间会怎样？那么operator delete[]时会出错，因为operator delete[]会首先读取一个int知道有多少个A要释放，你没有分配这个int，它可能读到一个不合理的值N，然后去释放，发现释放不了出现内存访问错误，或者N极大一直去释放，表现上程序永远结束不了。
三、重载你的new和delete
了解了上面的new和delete的过程可以怎样？既然C++已经为我们封装好了new和delete，为什么还要把他们赤裸裸的剥开。答案是：为了重载，为了定义我们自己的new和delete。
首先一个问题，你可以重载new和delete吗？答案是不能，刚学C++重载时，C++的标准就告诉我们new和delete操作是不能被重载的，但是有的时候我们确实需要定制一些我们自己的new和delete，（最简单的情形是我想统计我一共new了多少内存又delete了多少）。似乎没有解决方法了，但是看到了new和delete的内部，我们就有办法了，因为我们可以重载组成new和delete的各个关键步骤的operator new和operator delete！这是一个令人兴奋的消息。
为了重载我们要了解operator new 和delete各有几种形式，查查msdn,吓了一跳，包括[]形式一共有3*2*2=12种定义好的重载接口：
operator new：
A形式 这是new的第一步，分配内存
void *__cdecl operator new(
size_t count
);
B形式 这是for placement new
void *__cdecl operator new( size_t count, void * object ) throw();
C形式 这是不抛出异常的形式
void *__cdecl operator new(
size_t count,
const std::nothrow_t&
) throw();
operator delete：
void operator delete( void* _Ptr ) throw( ); void operator delete( void *, void * ) throw( ); void operator delete( void* _Ptr, const std::nothrow_t& ) throw( );
operator new[]:
void *operator new[]( std::size_t _Count ) throw(std::bad_alloc); void *operator new[]( std::size_t _Count, const std::nothrow_t& ) throw( ); void *operator new[]( std::size_t _Count, void* _Ptr ) throw( );
operator delete[]:
void operator delete[]( void* _Ptr ) throw( ); void operator delete[]( void *, void * ) throw( ); void operator delete[]( void* _Ptr, const std::nothrow_t& ) throw( );
C++的运算符重载分为全局重载和局部的类内的重载。
3.1 首先的全局重载，全局重载意味着代码内所有的new和delete的行为都被改变（包括你引用的库），要十分小心，甚至很多人说不要使用全局重载new和delete。
下面是我全局重载operator new和new[]的第一种A形式（C形式雷同），注意在以上这些操作中，在VS中A和C种方法都可以被用户全局重载，但是B种形式（也就是placement 形式）不允许被重载（它实现成了inline函数），不知道其他IDE是怎样的 规定，但是VS的规定是有道理的，因为我们几乎想不出有什么理由要placement new，它本就是一种为形式而生的形式。。。
//overload global operator new
void* operator new(size_t size){
cout<<"new "<<size<<endl;
void *ptr = (void *)malloc(size);
return ptr;
}
//overload global operator delete
void operator delete(void* p){
cout<<"delete "<<_msize(p)<<endl;
free(p);
return;
}
//overload global operator new[]
void* operator new[](size_t size){
cout<<"new[] "<<size<<endl;
void *ptr = (void *)malloc(size);
return ptr;
}
//overload global operator new[]
void operator delete[](void* p){
cout<<"delete[] "<<_msize(p)<<endl;
free(p);
return;
}
在我的重载中对于每次施放和分配都额外打印当前涉及内存的大小
3.2 类内重载，这种重载更加常用一些，这里要注意，对于类内重载，如果要调用placement new，那么B形式必须被重载，否则你的代码编不过，这与全局重载完全不同，以下是我对类内实现的A和B形式的重载：
class leon{
public:
leon(){
m_a=0;
}
leon(int a){
m_a=a;
}
~leon(){
}
//overload operator new
void* operator new(size_t size){
cout<<"new "<<size<<endl;
void *ptr = (void *)malloc(size);
return ptr;
}
void* operator new(size_t size,void* buf){
cout<<"new "<<size<<endl;
return buf;
}
//overload operator delete
void operator delete(void* p){
cout<<"delete "<<_msize(p)<<endl;
free(p);
return;
}
//overload global operator new[]
void* operator new[](size_t size){
cout<<"new[] "<<size<<endl;
void *ptr = (void *)malloc(size);
return ptr;
}
void* operator new[](size_t size,void* buf){
cout<<"new[] "<<size<<endl;
return buf;
}
//overload operator new[]
void operator delete[](void* p){
cout<<"delete[] "<<_msize(p)<<endl;
free(p);
return;
}
3.3 更多形式的重载：
其实除了c++定义好的A、B、C三种operator new（）接口，我们还可以自定义新的重载形似，如定义一个void* operator new(size_t size，bool b)，那么我就可以调用A* a=operator(sizeof(A),true)来执行我的一些特殊需求
四、operator new和delete及其重载的应用：
对new和delete重载可以在很多地方应用到：
最常见的就是一些内存管理和统计功能：你想知道你分配和释放了多少内存
内存泄露的监测：通过统计可以知道是否有内存泄露，甚至定位到于某处有泄露
另外通过使用placement new还可以在某些场合加快对象的创建，比如你可以事先分配好一片内存，然后利用placement new在上面直接创建，这样之后的每次创建不会再有反复的内存分配和释放操作
利用上面的特性可以实现某种内存池来加速内存访问
以上只是抛砖引玉，以后可以再实践中多利用C++的这个特性
最后更新：2017-04-03 16:48:51