定制类自己的的new_handler

　　C++中的new操作符首先使用operator new函数来分配空间，然后再在此空间上调用类的构造函数构造对象。当operator new无法分配所需的内存空间时，默认的情况下会抛出一个bad_alloc异常，在抛出这个异常之前，如果用户指定了错误处理函数即new_handler，则程序会先执行new_handler函数进行错误处理。为了设置这个错误处理函数，我们需要调用set_new_handler函数，它在std命名空间内的情况如下所示

namespace std{
    typedef void (*new_handler)();
    new_handler set_new_handler(new_handler p)throw ();
}

　　set_new_handler函数承若不抛出任何异常。该函数接受一个new_handler函数指针，且返回一个这样的指针。pNew代表的是如果operator new发生失败，采用的错误处理函数是pNew所指向的函数，set_new_handler函数返回的是以前的错误处理函数指针。比如，

void myErrorHandler(){
    cerr<<"can't need the request for memory";
    abort();
}
int main(){
    std::set_new_handler(myErrorHandler);
    int *ptr=new int[1000000000L];
    delete [] ptr;
    return ;
}

　　当出现无法满足内存分配要求的时候，程序会不断的调用myErrorHandler函数进行内存的分配，如果错误处理函数中没有abort(),终端会不断的打印错误提示。设置全局的set_new_handler，只要出现operator new失败，都会调用该错误处理函数。但是如果我们需要给不同的类设置不同的错误处理函数时，该怎么办呢？也就是说我们需要定制类自己的set_new_handler函数。

class Widget{
    public:
        static std::new_handler set_new_handler(std::new_handler pNew) throw ();
        static void* operator new(std::size_t size)throw (std::bad_alloc);
    private:
        static std::new_handler currentHandler;
        int array[100000000L];//为了容易让new Widget出现异常
};
std::new_handler Widget::currentHandler=0;

　　如上所示，类Widget需要定义自己的new_handler变量，而且需要定义自己的set_new_handler函数和operator new函数，set_new_handler函数比较简单，参照全局的set_new_handler函数的行为即可。

std::new_handler Widget::set_new_handler(std::new_handler pNew){
    std::new_handler oldHandler=currentHandler;
    currentHandler=pNew;
    return oldHandler;
}

　　函数set_new_handler设置新的new_handler，并且返回以前的new_handler。

　　那么Widget类中的operator new函数应该怎么定义呢？

　　首先，它应该设置本类的new_handler，怎么给Widget设置自己的new_handler并让其正常工作呢？调用std::set_new_handler即可，类中的currentHandler可作为其参数；

　　其次，调用std::operator new函数请求分配内存，但是，这里可能存在一个资源泄露的问题，如第一步，我们将全局的set_new_handler设置成类Widget的错误处理函数，如果分配失败，我们怎么将原来的new_handler再设置回去呢？很显然的一种方法就是通过对象来管理new_handler，如下

　　

class NewHandlerHolder{
    public:
        explicit NewHandlerHolder(new_handler p):oldHandler(p){}
        ~NewHandlerHoler(){
            std::set_new_handler(oldHander);
        }
    private:
        std::new_handler oldHandler;
        NewHandlerHolder(const NewHandlerHolder&);
        NewHandlerHolder& operator=(const NewHandlerHolder&);
};

　　这是一个资源管理类，如果我们定义了一个NewHandlerHolder对象来管理原来的new_handler，当内存分配失败时，抛出异常且函数退栈，同时也会调用已经构造的对象的析构函数，当我们调用NewHandlerHolder的析构函数时，会重新将原来的new_handler设置回去。用于资源管理的类在较多情况下不允许进行赋值和复制构造的动作，因为我们希望这个资源管理的对象具有资源唯一的管理权。

　　此时，我们就可以写出来Widget类中的operator new函数了。

void* Widget::operator new(std::size_t size) throw (std::bad_alloc){
    NewHandlerHolder temp(std::set_new_handler(currentHandler));
    return ::operator new(size);
}

　　定义完所有所需的内容后，我们可以使用定制的new_handler。

int main(){
    Widget::set_new_handler(myErrorHandler);
    //Widget::set_new_handler(0);
    while()
        Widget *ptr=new Widget;
}

　　运行结果如下图

　　

　　将注释的解注，运行结果没有"can't need the request for memory"。

　　以上思想就能为各个类编写自己的定制的new_handler，但是为每个需要编写定制new_handler的类写如此相似的代码，似乎有点不合理，为了避免代码重复，我们可以使用模板

　　

template<typename T>
class NewHandlerSupport{
    public:
        static std::new_handler set_new_handler(std::new_handler newHandler)throw ();
        static void* operator new(std::size_t size)throw (std::bad_alloc);
    private:
        static std::new_handler currentHandler;
};
template<typename T>
void* NewHandlerSupport<T>::operator new(std::size_t size){
    NewHandlerHolder temp(std::set_new_handler(currentHandler));
    return ::operator new(size);
}
template<typename T>
std::new_handler NewHandlerSupport<T>::set_new_handler(std::new_handler newHandler)throw(){
    std::new_handler oldHander=currentHandler;
    currentHandler=newHandler;
    return oldHandler;
}
template<typename T>
std::new_handler NewHandlerSupport<T>::currentHandler=;

　　如果我们希望类widget获得定制的new_handler行为，只需要将widget类以public继承NewHandlerSupport<widget>即可。我们只是希望获得不同模板参数所带来的不同的static std::new_handler currentHandler，我们需要用它来定制各个类的new_handler。