Article 49: understanding the behavior of new handler

Consider the following code ：

void outOfMem() {
    
    std::cerr << "unable to satisfy request for memory\n";
    std::abort();
}

int main() {
    
    std::set_new_handler(outOfMem);
    int *p = new int[1000000000000000]; // abnormal 
    return 0;
}

When operator new When a memory request cannot be satisfied , It's constantly calling new-handler function , Until you find enough memory .

Design a good new-handler The function must do the following

1. Make more memory available
2. Install another new-handler
3. Removal new-handler
4. Throw out bad_alloc
5. No return

Sometimes you want to deal with memory allocation failures in different ways ：

class X {
    
	public:
		static void outOfMemory();
};

class Y {
    
	public:
		static void outOfMemory();
};

X *p1 = new X; //  If the assignment is not successful , call X::outOfMemory
Y *p1 = new Y; //  If the assignment is not successful , call Y::outOfMemory

The solution is to make every class Provide your own set_new_hanlder and operator new：

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(new_handler p) throw()
{
    
    std::new_handler oldHandler = currentHandler;
    currentHandler = 0;
    return oldHandler;
}

Last ,Widget Of operator new Do the following

1. Call standard set_new_hanlder, inform Widge Error handling function
2. call global operator new, Perform the actual memory allocation
3. If global operator new Be able to allocate enough Widget Memory used by object ,Widget Of operator new Will return a pointer , Point to the distribution income

Implement the above operations with a resource management class ：

class NewHandlerHolder
{
    
public:
    explicit NewHandlerHolder(std::new_handler nh) : handler(nh){
    } //  Get the current new-hanlder
    ~NewHandlerHolder()
    {
     std::set_new_handler(handler);}

private:
    std::new_handler handler;
    NewHandlerHolder(const NewHandlerHolder&); //  prevent copy
    NewHandlerHolder & operator =(const NewHandlerHolder &);
};

Then implement Widget Of opeator new

void* Widget::operator new (std::size_t size) throw(std::bad_alloc)
{
    
    NewHandlerHolder h(std::set_new_handler(currentHandler)); //  install Widget Of new-handler
    return ::operator new(size);                             //  Allocate memory or throw an exception 
}  

The customer code is used as follows ：

    Widget::set_new_handler(outOfMem); //  Set up outOfMem by Widget Of new-handing
    Widget* pw1 = new Widget;          //  If memory allocation fails, call outOfmem
    std::string* ps = new std::string; //  If memory allocation fails, call global new-hanlding function 
    Widget::set_new_handler(0);        //  Set up Widget Of new-handing by null
    Widget* pw2 = new Widget;          //  If memory allocation fails , Throw an exception immediately