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++的这个特性