码迷,mamicode.com
首页 > 编程语言 > 详细

《Effective C++》:条款49:了解new-handler的行为

时间:2015-03-15 21:19:48      阅读:141      评论:0      收藏:0      [点我收藏+]

标签:c++   内存管理   高效c++   new-handle   

C++内存是由程序员手动管理的,不像Java或.net有垃圾回收机制。C++内存管理主要是分配例程和归还例程(allocation and deallocation routines),即operator new和operator delete,还有一个配合的角色new-handler。当涉及到数组时,上面提到的operator new和operator delete就会变为operator new[]和operator delete[]。

内存管理在多线程环境下更为复杂,因为heap是一个可被改动的全局性资源,多个线程访问同一个资源会有race conditions(竞速状态)。使用static类型变量更要注意。如果没有适当同步控制(synchronization),使用无锁(lock-free)算法或精心防止并发访问(concurrent access)时,可能会破坏heap数据结构。

最后要注意一点,STL容器使用的heap是由容器所拥有的分配器对象(allocator objects)管理,不是用new和delete直接管理。

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

当operator new无法满足某一内存分配时,就会抛出一次。以前它会返回NULL指针,现在某些旧式编译器也还这么做。

在operator new抛出异常以前,会先调用一个客户指定的错误处理函数:new-handler。(这不是全部,operator new更复杂,见**条款**51)。客户用set_new_handler来指定这个“用以处理内存不足”的函数,这是声明于new的标准程序库函数

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

new_handler是个函数指针,该函数没有参数也不返回任何东西。set_new_handler是设置一个new_handler并返回一个new_handler函数,返回的new_handler是指向set_new_handler被调用前正在执行的那个new-handler函数。后面的throw是一份异常明细,表示该函数不抛出异常。可以这样使用

    void outOfMem()
    {
        std::cerr<<"Unable to satisfy request for memoryn";
        std::abort();
    }
    int main()
    {
        std::set_new_handler(outOfMem);
        int *pBigDataArray=new int[100000000L];
        ……
    }

如果operator new无法为100000000个整数分配足够空间,outOfMem会被调用。

当operator new无法满足内存申请时,它会不断调用new-handler,直到找到足够内存。反复调用的代码在**条款**51讨论。这里先说一下,设计良好的new-handler必须做好以下事情;

  • 让更多内存可被使用。这样可以造成operator new内的下一次内存分配动作可能成功。一个做法是,程序一开始就分配一大块内存,当new-handler第一次被调用时将它释放。
  • 安装另一个new-handler。当前的new-handler无法取得更多内存时,或许它直到哪个new-handler有此能力。
  • 卸除new-handler。即将null指针传给set_new_handler,一旦没有安装任何new-handler,operator new在内存分配不成功时便抛出异常。
  • 抛出bad_alloc(或派生自bad_alloc)的异常。这样的异常不会被operator new捕捉,因此不会被传播到内存索求处。
  • 不返回。通常abort或exit。

有时候,我们希望处理内存分配失败的情况和class相关。例如

    class X{
    public:
        static void outOfMemory();
        ……
    };
    class Y{
    public:
        static void outOfMemory();
        ……
    };
    X* p1=new X;//分配不成功,调用X::outOfMemory
    Y* p2=new Y;//分配不成功,调用Y::outOfMemory

C++并不支持class专属的new-handler,但是我们自己可以实现这种行为。令每一个class提供自己的set_new_handler和operator new即可。……………………………………………………………………………………

现在打算处理Widget class内存分配失败的情况。首先要有一个operator new无法为Widget分配足够内存时的调用函数,即new_handler函数

 class Widget{
    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_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;
        reutrn oldHandler;
    }

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 operator new最终无法分配足够内存,会抛出一个bad_alloc异常。这时Widget的operator new要恢复原本的global new-handler,之后在传播异常。
3、如果global operator new调用成功,Widget的operator new会返回一个指针,指向分配的内存。Widget析构函数会管理global new-handler,它会将Widget’s operator new被调用前的那个global new-handler恢复回来。

    class NewHandlerHolder{
    public:
        explicit NewHandlerHolder(std::new_handler nh)
        :handlere(nh){}
        ~NewHandlerHolder()
        { std::set_new_handler(handler); }
    private:
        std::new_handler handler;
        NewHandlerHolder&(const NewHandlerHolder&);//防止copying
        NewHandlerHolder& operator-(const NewHandlerHolder&);
    };

这使得Widget’s operator new的实现变得简单

    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);
    }

Widget客户应该类似这样使用其new-handling

    void outOfMem();
    Widget::set_new_handler(outOfMem);//设定outOfmem为Widget的new-handling函数
    Widget* pw1=new Widget;//内存分配失败,则调用outOfMEM
    std::string* ps=new std::string;//内存分配失败则调用global new-handling(如果有)
    Widget::set_new_handler(0);//设定Widget专属new-handling为null
    Widget* pw2=new Widget;//内存分配失败则立刻抛出异常

实现这个方案的class代码基本相同,用个基类base class加以复用是个好的方法。可以用个template base class,如此以来每个derived class将获得实体互异的class data复件。这个base class让其derived class继承它获取set_new_handler和operator new,template部分确保每一个derived class获得一个实体互异的currentHandler成员变量。

 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_handler 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 oldHandler;
    }

    template<typename T> void* NewHandlerSupport<T>::operator new(std::size_t size)
    throw(std::bad_alloc)
    {
        NewHandlerHolder h(std::set_new_handler(currentHandler);
        return ::operator new(size);
    }
    //将每一个currentHandler初始化为null
    template<typename T>
    std::new_handler NewHandlerSupport<T>::currentHandler=0;
有了这个class template,为Widget添加set_new_handler就容易了

    class Widget:public NewHandlerSupport<Widget>{
    ……
    };

在template base class中,从未使用类型T。因为currentHandler是static类型,使用模板的话会是每个class都有自己的currentHandler。如果使用多重继承,要注意**条款**40所提到的内容。

C++中operator new分配失败抛出异常bad_alloc,但是旧标准是返回null指针。旧标准这个形式为nothrow形式。

 class Widget{};
    Widget* pw1=new Widget;//分配失败,抛出bad_alloc
    if(pw1==null)//判断是否分配成功。但是这个测试失败
    Widget* pw2=new(std::nothrow)Widget;//分配失败,返回null
    if(pw2==null)//可以侦测

new(std::nothrow) Widget发生两件事,第一分配内存给Widget对象,如果失败返回null指针。第二,如果成功,调用Widget的构造函数,但是在这个构造函数做什么,nothrow new并不知情,有可能再次开辟内存。如果在构造函数使用operator new开辟内存,那么还是有可能抛出异常并传播。使用nothrow new只能保证operator new不抛出异常,不能保证像new(std::nothrow) Widget这样的表达式不抛出异常。所以,并没有运用nothrow的需要。

总结

  • set_new_handler允许客户指定一个函数,在内存分配无法获得满足时被调用。
  • nothrow new是一个颇为局限的工具,因为它只适用于内存分配;后继的构造函数调用还是有可能抛出异常。

《Effective C++》:条款49:了解new-handler的行为

标签:c++   内存管理   高效c++   new-handle   

原文地址:http://blog.csdn.net/kangroger/article/details/44280793

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!