8 定制new和delete

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

new_handler  set_new_handler (new_handler new_p)  throw();

Sets  new_p  as the new handler function,  the old one is returned.

operator new抛出异常以反映一个未获满足的内存需求之前，它会先调用一个客户指定的错误处理函数，客户必须调用set_new_handler设定。

class NewHandlerHolder{

explicit NewHandlerHolder (std::new_handler  nh):handler(nh){}

~NewHandlerHolder(){std::set_new_handler(handler);}

private:

std::new_handler  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;

return oldHandler;

}

void*  Widget:: operator new (std::size_t  size) throw

{

NewHandlerHolder h( std::set_new_handler(currentHandler) );

return ::operator new(size);

}

使用：

void outOfMem();

Widget::set_new_handler(outOfMem);

Widget* pw1 = new Widget;

条款50：了解new和delete的合理替换时机

略

条款51：编写new和delete时需固守常规

实现一致性operator new必得返回正确的值，内存不足时必得调用new-handling函数，必须有对付0内存需求的准备。operator new返回值十分单纯，如果它有能力供应客户申请的内存，就返回一个指针指向那块内存，如果没有那个能力，抛出一个bad_alloc异常。

然而也不是非常单纯，因为operator new实际上不只一次尝试分配内存，并在每次失败后调用new-handling函数。这里假设new-handling函数能够做某些动作将内存释放出来，只有当new-handling指针为null时，operator new才会抛出异常。

下面是non-member operator new 伪码：

void * operator new(std::size_t  size) throw(std::bad_alloc)

{

using namespace std;

if(size == 0) size =1;

while(true){

尝试分配size bytes;

if 分配成功

return 一个指针指向分配的内存

new_handler  globalHandler  =  set_new_handler(0);

set_new_handler( globalHandler);

if( globalHandler ) (*globalHandler)();

         else throw std::bad_alloc();

}

}

许多人没有考虑operator new成员函数会被derived class继承。一旦被继承base class的operator new被调用以分配derived class对象。例如：

class Base{

public:  static void * operator new(std::size_t  size) throw(std::bad_alloc);

…

}

class Derived: public Base { … }

Derived* p = new Derived; //调用Base::operator new

解决方法：

void * Base::operator new(std::size_t  size) throw(std::bad_alloc)

{

if(size != sizeof(Base) ) return ::operator new(size);

…

}

条款52：写了placement new也要写placement delete

如果operator new接受的参数除了一定会有的那个size_t之外还有其他，这便是所谓的placement new。众多placement new版本中特别有用的一个是“接受一个指针指向对象该被构造之处”，那样的operator new声明如下：

void * operator new(std::size_t, void *)throw();

对于以下代码：

class Widget{

public:

static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);

static void  operator delete(void* pMemory, std::size_t size)throw( );

…

};

上述代码存在微妙的内存泄漏。它在动态创建一个Widget时将相关分配信息志记于cerr:

Widget* pw = new (std::cerr) Widget;

如果内存分配成功，但Widget构造函数抛出异常，运行系统有责任取消operator new的分配。运行系统会寻找参数个数和类型都 与operator new相同 的某个operator delete，如果找到，那就是它的调用对象。

class Widget{

public:

static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);

static void  operator delete(std::size_t size, std::ostream& logStream)throw( );

static void  operator delete(void* pMemory) throw( );

…

};

Widget* pw = new (std::cerr) Widget; //不再泄漏

但 delete pw;//调用正常的operator delete，而非 placement版本。

因此，我们必须同时提供一个正常的operator delete和一个placement版本（参数必须和operator new一样）。只要这样做，就不会有难以察觉的内存泄漏了。

另外，考虑到成员函数的名称会掩盖其外因作用域中的相同名称，例如：

class Base{

public:

static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);

…

};

Base* pb = new Base; //error,掩盖

Base* pb = new (std::cerr) Base; //OK

同理，derived classes 中的operator new掩盖global版本和继承版。

class Derived: public Base{

public:

static void* operator new(std::size_t size) throw(std::bad_alloc);

…

};

Derived* pd = new (std::clog) Derived; //error,掩盖

Derived* pd = new Derived;

解决办法：建立一个base class,内含所有正常形式的new 和 delete。

若想以自定义形式扩展标准形式的客户，可利用继承机制及using声明式取得标准形式。