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::outOfMemoryC++并不支持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是一个颇为局限的工具，因为它只适用于内存分配；后继的构造函数调用还是有可能抛出异常。