了解new-handler的行为
本节条款讲述的技术是，在operator new抛出异常以前，会先调用一个客户指定的错误处理函数：new-handler。当内存分配失败的时候如何自定义并使用这个内存异常处理函数。关键语句就是set_new_handler。作者重点强调如何对于class的内存分配，实现不同的内存分配错误处理函数。
我们先来举个书上的例子，先弄明白如何使用new-handler技术。
如下代码：
void outOfMem()
{
std::cerr<<"Unable to satisfy request for memoryn";
std::abort();//强制终止所在进程
}
int main()
{
std::set_new_handler(outOfMem);
int *pBigDataArray=new int[100000000L];
return 0;
}如上代码，因为调用了set_new_handler(outOfMem);，如果内存分配失败，则会转到outOfMen函数继续执行。这样我们就萌发出对于我们自己定义的不同类，能不能实现不同类的内存分配问题用不同的函数进行处理的想法。比如说类A有类A的自定义内存处理函数，类B有类B的自定义内存处理函数，为了实现这种功能，作者提出了以下实现方法。
不过顺带提一下，我们定义的内存处理函数要有以下特点：
1.让更多内存可被使用。这样可以造成operator new内的下一次内存分配动作可能成功。一个做法是，程序一开始就分配一大块内存，当new-handler第一次被调用时将它释放。
2.安装另一个new-handler。当前的new-handler无法取得更多内存时，或许它直到哪个new-handler有此能力。
3.卸除new-handler。即将null指针传给set_new_handler，一旦没有安装任何new-handler，operator new在内存分配不成功时便抛出异常。
4.抛出bad_alloc(或派生自bad_alloc)的异常。这样的异常不会被operator new捕捉，因此不会被传播到内存索求处。
5.不返回。通常abort或exit。
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&);
};
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;
}
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);
}
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 NewHandlerHolder，是为了保存替换前的内存处理函数，我们来跟踪一下以上代码的执行过程。首先，声明一个outOfMem()，接着通过Widget::set_new_handler(outOfMem)语句设置Widget内的static std::new_handler currentHandler变量。然后，调用new Widget时，我们进入Widget::operator new(std::size_t size) throw(std::bad_alloc)函数体内，NewHandlerHolder h(std::set_new_handler(currentHandler));语句起到的作用如下，1.在定义一个NewHandlerHolder对象的时候将替换前的内存处理函数保存在该对象的std::new_handler handler变量中，2.设置新的针对类Widget的new_handler函数。执行::operator new(size)进行内存分配，如果内存分配出错则调用刚替换的内存处理函数。在退出该函数体的时候，因为NewHandlerHolder的析构函数的，还原内存处理函数，不影响以后别的内存分配异常的执行。
以上版本实现了我们的需求功能。
然而，作者又提出了另一种利用模板实现的方法：
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&);
};
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);
template<typename T>
std::new_handler NewHandlerSupport<T>::currentHandler=0;
class Widget:public NewHandlerSupport<Widget>{
};这种实现方式对我来说，暂时感觉别扭，可是它却体现出模板潜在的编程价值。当我们调用语句class Widget:public NewHandlerSupport<Widget>时，我们实例化了一个NewHandlerSupport<Widget>类，我们的类Widget继承自该类，所以widget类中继承了NewHandlerSupport的函数，实际程序执行过程和第一种方式一样，唯一不同的地方就是类widget不用重新定义有关内存处理的静态函数。