解析
new
平常使用的new都是new operator（new操作符），它是语言内置的，无法重载。
new的第一种写法：
//call new operator
int *p = new int(3);调用new operator后做了两件事：
1、调用operator new分配内存。
2、调用构造函数初始化对象。
operator new声明如下：
//operator new's declaration
void * operator new(size_t size);
它可以被重载，但是第一个参数类型必须是size_t, 决定分配内存的大小。
可以调用operator new只进行内存分配：
//call operator new
void *v = operator new(4);
new的第二种写法：
//another way of calling new operator
int *i = new(v)int(5);
调用new operator后做了两件事：
1、调用placement new，这里不分配内存，只返回传入的指向内存的指针。
2、调用构造函数初始化对象。
placement new的实现可能像这样：
//placement new
void * operator new(size_t, void *location)
{
return location;
}
全局的placement new不能被重载，也就是说无法定义声明为 void* operator new(size_t, void* ) 的函数。
new的第三种写法：
//array
int *p = new int[4];
调用new operator后做了两件事：
1、调用operator new[]，分配内存。
2、对数组里的每一个对象调用构造函数。
可重载，声明如下：
//operator new[]'s declaration
void* operator new[](size_t);
delete:
平常使用的delete是delete operator（delete操作符），不能被重载。
delete的第一种写法：
//delete operator
delete p;
调用delete operator时做了如下两件事：
1、调用析构函数。
2、调用operator delete释放内存。
operator delete声明如下：
//operator delete's declaration
void operator delete(void *p)
operator delete只释放内存，不调用析构函数，可以被重载，可以像这样调用：
//call operator delete
operator delete(p);
delete的第二种写法：
//array
delete[] p;
调用delete operator时做了如下两件事：
1、对数组里的每个对象调用析构函数。
2、调用operator delete[]释放内存。
可重载，声明如下：
//operator delete[]'s declaration
void operator delete[](void* p)
内存分配失败时的情况
使用new分配内存失败时会抛出异常std::bad_alloc,所以如下if条件不会满足：
int *p = new int;
if(NULL == p) //此条件不会满足
若用这种方式，则内存分配失败时不会抛出异常，返回空指针：
int *p = new(nothrow) int; //类似placement new的new operator调用
if(NULL == p) //此条件可能满足
set_new_handler可以用来设置operator new分配内存出错时所调用的错误处理函数，它在<new>中声明如下：
typedef void (* new_handler) ();
new_handler set_new_handler(new_handler) throw ()；
new_handler是指向错误处理函数的函数指针。
当用operator new分配内存失败时，首先调用set_new_handler设置的错误处理函数，然后抛出std::bad_alloc异常。
所以可以通过重载operator new和set_new_handler,针对某一个类，设置特定的内存分配错误时的处理，而不影响全局的new_handler,实现如下：
class Allocate
{
public:
//重载set_new_handler,设置自己的内存分配错误处理函数
static new_handler set_new_handler(new_handler p);
//重载operator new,在异常抛出前或者成功返回前恢复全局的new_handler
static void* operator new(size_t size);
private:
//保存自己的内存分配错误处理函数
static new_handler current_handler;
};
//初始化类的static数据成员
new_handler Allocate::current_handler = NULL;
//重载set_new_handler
new_handler Allocate::set_new_handler(new_handler p)
{
//保存当前传入的new_handler,返回之前的new_handler
new_handler old_handler = current_handler;
current_handler = p;
return old_handler;
}
//重载operator new
void* Allocate::operator new(size_t size)
{
//保存全局的new_handler,传入当前的new_handler
new_handler globe_handler = std::set_new_handler(current_handler);
void *memory = NULL;
try
{
//调用全局的operator new分配内存
memory = ::operator new(size);
}
catch(std::bad_alloc)
{
//分配内存失败，抛出异常前已经调用了前面设置的new_handler
//现在恢复之前的全局new_handler,并rethrow异常
std::set_new_handler(globe_handler);
throw;
}
//内存分配成功，恢复全局的new_handler
std::set_new_handler(globe_handler);
return memory;
}
重载set_new_handler使别人可以为这个类设置内存分配出错的处理函数。
重载operator new先用此类的new_handler替换了全局的new_handler,保证operator new分配内存失败时会调用自己的错误处理函数，
在离开前恢复全局的new_handler,保证其它类型的operator new失败时还会使用全局的new_handler.
使用如下：
//为Allocate类设置内存分配出错处理函数
Allocate::set_new_handler(NoMemory);
//new
Allocate *p = new Allocate;
delete p;
重载operator new和operator delete的注意事项
new：
1、如果成功返回指向内存的指针，如果失败抛出std::bad_alloc异常。
2、c++标准要求，在请求0字节分配时也要返回合法指针。
3、operator new中存在一个无限循环，以下几种情况可以跳出循环：
分配内存成功，return指向内存的指针；
外界通过set_new_handler(NULL)卸载了new_handler,导致抛出std::bad_alloc异常。
否则就会一直循环，执行new_handler。
4、注意父类的operator new可能会被子类调用，子类的size可能会比父类大。
实现伪代码：
void * operator new(size_t size)
{
if (size == 0)
{
// 处理0字节请求时,把它当作1个字节请求来处理
size = 1;
}
while (1)
{
分配size字节内存;
if (分配成功)
return (指向内存的指针);
// 分配不成功，找出当前出错处理函数
new_handler globalhandler = set_new_handler(0);
set_new_handler(globalhandler);
if (globalhandler) (*globalhandler)();
else throw std::bad_alloc();
}
}
delete：
为了保证删除空指针是安全的，需要判断传入指针是否为空。
重载operator的规则：
1、operator new的返回值是void*，第一个参数是size_t，格式：
void* operator new(size_t, para2, para3)
调用时格式：
void *p = new(para2, para3)TYPE;
2、operator delete的返回值为void，第一个参数是void*，格式：
void operator delete(void*, para2, para3)
调用时格式：
delete p //调用void operator delete(void*)
operator delete(p, para2, para3) //调用void operator delete(void*， para2， para3)
全局的重载
void* operator new(size_t) {cout<<"new(size_t)"<<endl; return NULL;}
void* operator new(size_t, int) {cout<<"new(size_t, int)"<<endl; return NULL;}
//无法重载全局的placement new,报错
//void* operator new(size_t, void*) {cout<<"new(size_t, void*)"<<endl; return NULL;}
void* operator new[] (size_t) {cout<<"new[] (size_t)"<<endl; return NULL;}
void* operator new[] (size_t, int) {cout<<"new[] (size_t, int)"<<endl; return NULL;}
//无法重载全局的placement new,报错
//void* operator new[] (size_t, void*) {cout<<"new(size_t, void*)"<<endl; return NULL;}
//operator delete
void operator delete(void*) {cout<<"delete(void*)"<<endl;}
void operator delete(void*, size_t) {cout<<"delete(void*, size_t)"<<endl;}
void operator delete[](void*) {cout<<"delete[](void*)"<<endl;}
void operator delete[](void*, size_t) {cout<<"delete(void*, size_t)"<<endl;}
调用：
int *p = new int; //call operator new(size_t)
int *p1 = new(2)int; //call operator new(size_t, int)
delete p; //call operator delete(void*)
int *p2 = new int[3]; //call operator new[] (size_t)
int *p3 = new(3) int[3]; //call operator new[] (size_t, int)
delete[] p2; //call delete[](void*)
若没有重载operator new(size_t) 和operator delete(void*) ，则调用全局的。
传说void operator delete(void*, size_t) 会在catch到异常时被调到。
[]格式同上。
类中的重载
class Object
{
public:
//operator new
void* operator new(size_t) {cout<<"new(size_t)"<<endl; return NULL;}
void* operator new(size_t, void*) {cout<<"new(size_t, void*)"<<endl; return NULL;}
//operator delete
void operator delete(void*) {cout<<"delete(void*)"<<endl;}
void operator delete(void*, size_t) {cout<<"delete(void*, size_t)"<<endl;}
};
调用：
Object *p = new Object; //call operator new(size_t)
Object *p1 = new(NULL) Object; //call operator new(size_t, void*)
delete p; //call delete(void*)
若类中没有定义
void operator delete(void*)，则delete p调用void operator delete(void*, size_t)
若类中没有定义void* operator new(size_t) ，则 Object *p = new Object 报错，重载的非单参数的operator new隐藏了全局的单参数的operator new。
[]格式同上。
所以类中最好重载一下标准形式的operator new：
class Overload
{
public:
//重载operator new
static void* operator new(size_t size, int i, char c){return NULL;}
static void* operator new(size_t size){return ::operator new(size);}
};