重载new和delete

当我们创建一个new表达式时，会发生两件事，首先，使用operator new()来分配内存，然后调用构造函数。在delete表达式里，调用了析构函数，然后使用operator delete()释放内存。我们无法控制构造函数和析构函数的调用（这是编译器自动做的事），但可以改变内存分配函数operator new()和operator delete()。

1.为什么要重载

使用了new和delete的内存分配系统是为通用目的而设计的。但在特殊情况下，它不能满足需要（比如假设默认的分配策略适合分配小的内存块，而我们经常需要分配大块内存）。C/C++允许重载new和delete来实现我们自己的内存分配策略。

2.重载时发生了什么

当重载new和delete时，我们只是改变了原有的内存分配策略，记住这点很关键。编译器将用重载后的new代替默认版本取分配内存，然后为那个内存块调用构造函数。所以，当编译器看到new时，编译器分配内存并调用构造函数，但是当重载new时，可以改变的只是内存分配部分（delete也一样）。

当重载operator new()时，也可以替换它用完内存时的行为，所以必须在operator new()里决定做什么：返回0、写一个调用new-handler的循环、再试着分配或者产生bad_alloc的异常信息。

重载new和delete与重载其他运算符一样。但可以选择重载全局内存分配函数或者是特定类的内存分配函数。

3.如何重载

重载全局的new和delete

当全局版本的new和delete不能满足需要时，对其重载是很极端的方法。如果重载了全局版本，那么默认版本将完全无法访问（在这个重新定义里也不能调用它们）。

重载的new必须有一个size_t类型的参数，这个参数由编译器产生并传递给我们，它是要分配内存的对象的长度（使用new时，后面接一个对象，编译器会知道这个对象的大小）。必须返回一个指向等于（或者大于）这个长度的对象的指针，如果没有找到可用内存，则返回0。然而如果找不到可用内存，不能仅仅返回0，也许还应该做一些诸如调用new-handler或者产生一个异常信息之类的事。

operator new()返回值是一个void*，而不是指向某个具体类型的指针。所做的事情只是分配内存，而不是完成一个对象的建立——直到调用了构造函数才算完成了对象的构建，它是编译器确保的动作，不在我们可控范围内。

oeprator delete()的参数是一个指向由operator new()分配的内存的void*。参数是一个void*是因为它是调用析构函数之后得到的指针。析构函数从存储单元中移除对象。operator delete()返回值是void。

煮个栗子：

//GlobalOperatorNew.cpp//Overloat global new/delete#include 
   
    #include 
    
     using namespace std;void* operator new(size_t sz){    printf("operator new: %d Bytes\n", sz);    void *m = malloc(sz);    if(!m)  puts("out of memory");    return m;}void operator delete(void *m){    puts("operator delete");    free(m);}class S{    int i[100];public:    S() { puts("S:S()"); }    ~S() { puts("S:~S()");  }};int main(){    puts("creating & destroying an int");    int *p = new int(47);    delete p;    puts("creating & destroying an S");    S *s = new S;    delete s;    puts("creating & destroying S[3]");    S *sa = new S[3];    delete []sa;}

这里可以看到重载new和delete的通常形式，这里的内存分配使用了标准C函数库的malloc和free（可能默认的new和delete也使用这些函数）。注意，这里打印信息使用的是printf()和puts()而不是iostreams。因为，当创建一个iostream对象（像cin,cout和cerr），它们调用new取分配内存。而用printf()不会进入死锁状态，因为它不调用new来初始化。

对于一个类重载new和delete

为一个类重载new和delete时，尽管不必显式的使用static，但实际上仍然是创建static成员函数。它的语法也和重载其他运算符一样。当编译器看到使用new创建自己定义的类的对象时，它选择成员版本的operator new()而不是全局版本的new()。但是全局版本的new和delete任然为其他类型所使用。

下面的例子里为类Framis创建了一个简单的内存分配系统。程序开始时在静态数据区留出一块存储单元。这块内存被用来为Framis类型的对象分配存储空间。

//Framis.cpp//Local overloaded new & delete#include 
   
      //Size_t#include 
    
     #include 
     
      #include 
      
       using namespace std;ofstream out("Framis.out");class Framis{    enum { sz = 10; };   //古老的定义类内静态常量成员的方法    char c[sz]; //为了占据空间，不使用    static unsigned char pool[];    static bool alloc_map[];public:    enum { psize = 100; };    Framis() { out << "Framis()\n"; }    ~Framis() { out << "~Framis()\n"; }    void * operator new(size_t) throw(bad_alloc);    void operator delete(void *) ;};unsigned char Framis::pool[psize * sizeof(Framis)];bool Framis::alloc_map[psize] = {
  false};void* Framis::operator new(size_t) throw(bad_alloc){    for(int i = 0; i < psize; i++){        if(!alloc_map[i]){            out << "using block " << i << "...";            alloc_map[i] = true;            return pool + (i * sizeof(Framis));        }    out << "out of memory" << endl;    throw bad_alloc();}void Framis::operator delete(void *m){    if(!m) return ;    unsigned long block = (unsigned long)m - (unsigned long)pool;    block /= sizeof(Framis);    out << "freeing block" << block << endl;    alloc_map[block] = false;}int main(){    Framis * f[Framis::psize];    try{        for(int i = 0; i < Framis::psisz; i++){            f[i] = new Framis;        new Framis;     //out of memory    } catch(bad_alloc){        cerr << "Out of memory!" << endl;    }    delete f[10];    f[10] = 0;    Framis *x = new Framis;    delete x;    for(int i = 0; i < Framis::psize; i++)        delete f[i];    //Delete f[10] OK}

为一个类数组重载new和delete

如果为一个类重载了operator new和operator delete，那么无论何时创建一个这个类的对象，都会调用重载的new和delete。但如果要创建这个类的一个数组的话，编译器会使用全局的new和delete。所以我们还要重载这个类的new的数组版本。即operator new[]和operator delete[]。

//ArrayOperatorNew.cpp#include 
   
      //size_t definitoin#include 
    
     using namespace std;ofstream trace("ArrayOperatorNew.out");class Widget{    enum { sz = 10; };    int i[sz];public:    Widget() { trace << "*"; }    ~Widget() { trace << "~"; }    void* operator new(size_t sz){        trace << "Widget::new: " << sz            << " bytes" << endl;        return ::new char[sz];    }    void operator delete(void *m){        trace << "Widget::delete" << endl;        ::delete []p;    }    void* operator new[](size_t sz){        trace << "Widget::new[]: " << sz             << " bytes" << endl;        return ::new char[sz];    }    void operator delete[](void *p){        trace << "Widget::delete[]: " << endl;        ::delete []p;    }};int main(){    trace << "new Widget " <

输出信息：

new Widget Widget::new: 40 bytes*delete Widget~Widget::deletenew Widget[25]Widget::new[]: 1004 bytes*************************delete []Widget~~~~~~~~~~~~~~~~~~~~~~~~~Widget::delete[]:

这里重载的new和delete只是一个套用了全局new和delete的壳子，当然，可以在重载的new和delete里使用任意的内存分配方案。

在语法上，除了多一对括号之外，数组版本的new和delete与单个对象版本的是一样的。不管是哪个版本，我们都要决定所要分配的内存的大小（根据编译器给出的形参决定，可以大于）。数组版本的大小指的是整个数组的大小。应该明确，重载new唯一要做的是返回一个足够大的内存块的指针。然后编译器负责初始化它。

使用数组版本的new时，需要的长度比期望的多了4个字节。这额外的4字节是系统用来存放数组信息的，特别是数组对象的数量。当用delete []widget;表达式时，方括号就告诉编译器他是一个数组，所以编译器产生寻找数组大小的代码，然后多次调用析构函数。

4.分配失败怎么办

如果使用了new的内存分配没有成功，构造函数不会调用，所以虽然没有成功的创建对象，但至少没有调用构造函数并传给它一个为0的this指针。在以前的C++版本中，如果内存分配失败，一般是返回0。它将是构造函数不被调用。如果试着在一个标准的编译器中由new返回0值，则会被告知应该产生一个bad_alloc。

5.定位new和delete

重载operator new还有两个不常见的用途：

在内存的指定位置放置一个对象。

让使用new的程序员可以选择不同的内存分配方案

这两个特性可以用相同的机制实现：重载的operator new()可以带一个或多个参数。第一个参数总是对象的长度，它在编译器内部计算出来并传递给new，但其他参数可以由我们定义：一个放置对象的地址、一个是对内存分配函数或对象的引用，或其他设置。

在调用过程中传递额外参数给operator new的方法看起来有点古怪：在关键字new后是参数表（没有size_t参数，它由编译器处理），参数后面是正在创建的对象的类名字。例如：

X* xp = new(a) X;

将a作为第二个参数传递个operator new。注意，这是在operator new已经声明的情况下才有效。

//PlacementOperatorNew.cpp#include 
   
    #include 
    
     using namespace std;class X{    int i;public:    X(int ii = 0) i(ii) {        cout << "this = " << this << endl;    }    ~X(){        cout << "X::~X(): " << this << endl;    }    void* operator new(size_t,void *loc){        return loc;    }};int main(){    int l[10];    cout << "l = " << l << endl;    X* xp = new(l) X(47);    xp->X::~X();    //显式调用析构函数}

虽然本例只使用了一个附加参数，但若要实现其他目的，使用更多的参数也是可以的。

在销毁对象时会出现两难的局面。因为仅有一个版本的operator delete，所以没有办法说“对这个对象使用我的特殊的内存释放器”，所以可以调用析构函数，但不能使用动态内存释放机制释放内存，因为内存不是在堆上分配的（本例中该数组是在一个局部有效的栈上）。解决方法是非常特殊的语法：显示调用析构函数。

显示调用析构函数可能出现一些问题。由于某些人想要实时地决定对象的生存时间时，他们使用这种方法在范围结束之前销毁对象，而不是调节作用范围或者使用动态对象创建。而如果使用这种方法为在栈上的对象调用析构函数时，将会出现严重的问题，因为析构函数在对象超出作用范围时又会被调用一次。如果为在堆上创建的对象用这种方法调用析构函数，析构函数将被执行，但是内存不会被释放。用这种方法显式调用析构函数，其实只有一个原因，即支持operator new的定位语法。

还有一个定位operator delete，它仅在一个定位operator new表达式的构造函数产生一个异常信息时才被调用（因此该内存在异常处理操作中被自动清除了）。定位operator delete和定位operator new有一个对应的参数表，该定位operator new是指在构造函数产生异常信息之前被调用的那个。//TODO

转载地址：http://yeqbb.baihongyu.com/

你可能感兴趣的文章