C++之了解new-handler的行为（49）---《Effective C++》

最新推荐文章于 2022-07-23 17:53:54 发布

阿华Go

最新推荐文章于 2022-07-23 17:53:54 发布

阅读量406

点赞数

分类专栏： C++ new-handle 文章标签： C++

本文链接：https://blog.csdn.net/u014038273/article/details/77199555

版权

C++ 同时被 2 个专栏收录

141 篇文章 2 订阅

订阅专栏

new-handle

1 篇文章 0 订阅

订阅专栏

条款49：了解new-handler的行为

了解C++内存管理例程，即了解分配例程和归还例程（operator new和operator delete），同时还需要了解配角new-handler，这是当operator new无法满足客户的内存需求时所调用的函数。本篇博客主要讲解new handler的相关知识。

operator new抛出异常以反映一个未获满足的内存需求之前，它回西安调用一个客户指定的错误处理函数，即new_handler函数；为了指定这个“用以处理内存不足”地函数，客户必须调用set_new_handler，那是声明于<new>的一个标准程序库函数：

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

可以看到，new_handler是个typedef，定义出一个指针指向函数，该函数没有参数也不返回任何东西，set_new_handler则是一个“获得new_handler并返回一个new_handler”的函数。set_new_handler的声明式尾端的“throw()”是一份异常明细，表示该函数不抛出任何异常。set_new_handler的参数是个指针，指向operator new无法分配足够内存时候该调用的new_handler函数，其返回值也是个指针，指向set_new_handler被调用前正在执行的那个new_handler函数。
下面代码有助于理解new_handler和set_new_handler函数，代码如下：

void outofMem(){
    std::cerr<<"Unable to satisfy request for memory\n";
    std::abort();
}
int main(){
    std::set_new_handler(outOfMem);
    int* pBigDataArray=new int[100000001];
    ...
};

当operator new无法满足内存申请时，他会不断调用new_handler函数，直到找到足够内存。
new_handler需要做到以下事情：
1）让更多的内存可以被使用；
2）安装另一个new_handler;
3）卸载new_handler;
4）抛出bad_alloc（或者派生子bad_alloc）的异常；
5）不返回，通常调用abort或者exit。

假设，我们现在打算处理Widget class的内存分配失败情况，首先需要定义new_handler函数，设计如下：

class Widget{
public:
    static std::new_handler set_new_handler(std::new_handler p) throw();
    static void* opreator new(std::size_t size) throw(std::bad_alloc);
private:
    static std::new_handler currentHandler;
};
std::new_handler Widget::currentHandler=0;
std::new_handler Widget::set_new_handler(std::new_handler p) throw(){
    std::new_handler oldHandler=currentHandler;
    currentHandler=p;
    return oldHandler;
}

class NewHandlerHolder{
public:
    explicit NewHandlerHolder(std::new_handler nh):handler(nh){}
    ~NewHandlerHolder(){
        std::set_new_handler(handelr);
    }
private:
    std::new_handler handlder;
    NewHandlerHolder(const NewHandlerHolder(const NewHandlerHolder&);
    NewHandlerHolder& operator=(const NewHandlerHolder&);
};

void* Widget::operator new(std::size_t size) throw(std::bad_alloc){
    NewHandlerHolder h(std::set_new_handler(currentHandler));//安装Widget的new_handler
    return ::operator new(size);//分配内存或者抛出异常，恢复global new_handler；
}

//set_new_handler
void outOfMem();
Widget::set_new_handler(outOfMem);
Widget* pw1=new Widget;
Widget::set_new_hanlder(0);
Widget* pw2=new Widget;

Widget的operator new做一下事情。
1）调用标准set_new_handler，告知Widget的错误处理函数。者会将Widget的new_handler安装位global new_handler;
2）调用global operator new，小执行那个十几内存分配，如果分配失败，global operator new会调用Widget的new_handler，因为刚才那个函数才被安装为global new_handler。如果global new最终无法分配足够内存，会抛出一个bad_alloc异常，再次情况下Widget的operator new必须恢复为原本的new_handler然后再去传播该异常；
3）如果global operator new能够分配足够一个 Widget对象所用的内存，Widget的operator new便会返回一个指针，指向分配所得。Widget析构函数会管理global new_handler，它会自动将Widget’s operator调用前的那个global new_handler恢复回来。

2、适用于所有classes的class template new_hanlder

template <typename T>
class NewHandlerSupport{
public:
    static std::new_handler set_new_handler(std::new_handler p) throw();
    static void* operator new(std::size_t size) throw(std::bad_alloc);
    ...
private:
    static std::new_hanlder currentHandler;
};
template <typename T>
std::new_handler NewHandlerSupport<T>::set_new_handler(std::new_handler p) throw(){
    std::new_handler oldHandler=currentHandler;
    currentHandler=p;
    return oldHanlder;
}
template <typename T>
void* NewHanlderSupport<T>::operator new(std::size_t size) throw(std::bad_alloc){
    NewHandlerHolder h(std::set_new_hanlder(currentHandlder);
    return ::operator new(size);
}
template <typename T>
std::new_handler NewHanlderSupport<T>::currentHandler=0;
class Widget::public NewHnalderSupport<Widget>{
    ...
    //和先前一样，但不必声明set_new_handler或者operator new
};