new delete重载

/*
     示例代码
*/
#include <iostream>
#include <cstring>
using namespace std;
#define str "hello world!"
class Buffer
{
public:
        int bufwrite(char* content, size_t size);
        int bufread(size_t size);
        static void* operator new(size_t length, size_t size);
        static void operator delete(void* buffer);
/*private:*/
        static char* buf;
        static size_t buffersize;
};
void* Buffer::operator new(size_t length, size_t size)
{
        cout<<"my new()"<<endl;
        buffersize = size;
        buf = new char [size];
        cout<<"buffersize = "<<size<<endl;
        return ::operator new(length);
}
void Buffer::operator delete(void* buffer)
{
        cout<<"my delete()"<<endl;
        buffersize = 0;
        delete(buf);
        ::operator delete(buffer);
}
int Buffer::bufwrite(char* content, size_t size)
{
        memcpy(buf, content, size);
}
int Buffer::bufread(size_t size)
{
        for(int i=0; i<size; i++)
                cout <<buf[i];
        cout<<endl;
}
char* Buffer::buf               = 0;
size_t Buffer::buffersize       = 0;
int main()
{
        Buffer* mybuffer = new (100) Buffer();

        char* string = new char [strlen(str)+1];                                                                                                     
        strcpy(string, str);                                                                                                                         
        mybuffer->bufwrite(string, strlen(str));                                                                                                     
        mybuffer->bufread(strlen(str));                                                                                                              
        delete(mybuffer);                                                                                                                            
        delete(string);
        return 0;                                                                
} 

C++中的operator new与new operator，看上去挺像的两姐妹，却有天壤之别。operator new（1）       只分配所要求的空间，不调用相关对象的构造函数。当无法满足所要求分配的空间时，则        ->如果有new_handler，则调用new_handler，否则        ->如果没要求不抛出异常（以nothrow参数表达），则执行bad_alloc异常，否则        ->返回0（2）       可以被重载（3）       重载时，返回类型必须声明为void*（4）       重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为size_t（5）       重载时，可以带其它参数 new operator（1）       调用operator new分配足够的空间，并调用相关对象的构造函数（2）       不可以被重载 相应地，operator delete与delete operator有相似的特性。 举个例子 class X
{
public:
…………
     static void* operator new(size_t size)
{
     return ::operator new(size);
}

static void operator delete(void* pointee)
{
     ::operator delete(pointee);
}
…………
};

X* px = new X();
该行代码中的new为new operator，它将调用类X中的operator new，为该类的对象分配空间，然后调用当前实例的构造函数。 delete px; 该行代码中的delete为delete operator，它将调用该实例的析构函数，然后调用类X中的operator delete，以释放该实例占用的空间。 new operator与delete operator的行为是不能够也不应该被改变，这是C++标准作出的承诺。而operator new与operator delete和C语言中的malloc与free对应，只负责分配及释放空间。但使用operator new分配的空间必须使用operator delete来释放，而不能使用free，因为它们对内存使用的登记方式不同。反过来亦是一样。 你可以重载operator new和operator delete以实现对内存管理的不同要求，但你不能重载new operator或delete operator以改变它们的行为。 当重载operator new时，可以提供更多的参数，在new一个对象时，通过在关键字new后的括号传递额外的参数。比如以下的类 class A
{
public:
     …………
     static void* operator new(size_t size, const string& example)
{
     cout << example << endl;
     return ::operator new(size);
}
…………
};

A* pa = new (“This will be printed out in operator new”) A();
新标准的C++允许以这样的方式传递一个名为nothrow的参数，以表明当为该对象分配空间失败时，不抛出异常，而是返回0，以兼容旧标准new的行为。比如 class B {};

B* pb = new (nothrow) B();


当然这只能对那些使用默认operator new操作符的类。对已经重载了operator new的类（比如上面的X和A），如果不声明能接受nothrow参数，自然无法享受C++标准带来的礼物。