effective C++: 8.定制new和delete - c++编程基础

它现在可以用在任何需要它的 class 之上：

template // "mixin-style" base class for
class NewHandlerSupport{ // class-specific set_new_handler
public: // support

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

... // other versions of op. new ―
// see Item 52
private:
static std::new_handler currentHandler;
};

template
std::new_handler
NewHandlerSupport ::set_new_handler(std::new_handler p) throw()
{
std::new_handler oldHandler = currentHandler;
currentHandler = p;
return oldHandler;
}

template
void* NewHandlerSupport ::operator new(std::size_t size)
throw(std::bad_alloc)
{
NewHandlerHolder h(std::set_new_handler(currentHandler));
return ::operator new(size);
}
// this initializes each currentHandler to null
template
std::new_handler NewHandlerSupport ::currentHandler = 0;

有了这个 class template（类模板），为 Widget 增加 set_new_handler 支持就很容易了：Widget 只需要从 NewHandlerSupport 继承即可。（

可能看起来很奇特，但是下面我将解释更多的细节。）

class Widget: public NewHandlerSupport {
... // as before, but without declarations for
}; // set_new_handler or operator new

这些就是 Widget 为了提供一个 class-specific set_new_handler 所需要做的全部。
但是也许你依然在为 Widget 从 NewHandlerSupport 继承而烦恼。如果是这样，当你注意到 NewHandlerSupport template 从来没有用到它的

type parameter T 时，你可能会更加烦恼。它不需要那样做。我们需要的全部就是为每一个从 NewHandlerSupport 继承的 class 提供一份不同的

NewHandlerSupport ――特别是它的 static data member（静态数据成员）currentHandler ――的拷贝。template parameter T 只是为了将一个

inheriting class 同另一个区分开来。template 机制自己自动地为每一个被实例化的 NewHandlerSupport 中的 T 生成一个 currentHandler 的拷贝。

对于 Widget 从一个把 Widget 当作一个 type parameter（类型参数）的 templatized base class（模板化基类）继承，如果这个概念把你弄得有点糊涂

，不必难受。它最开始对每一个人都有这种影响。然而，它发展成如此有用的一项技术，它有一个名字，虽然它正常看上去所反映的事实并不是他们第一次

看到它的样子。它被称作 curiously recurring template pattern（奇特的递归模板模式） (CRTP)。真的。

在这一点上，我发表了一篇文章建议一个更好的名字叫做 "Do It For Me"，因为当 Widget 从 NewHandlerSupport 继承时，它其实是在说：“我

是 Widget，而我要从针对 Widget 的 NewHandlerSupport class 继承。”没有人使用我提议的名字（甚至是我自己），但是把 CRTP 考虑成说 "do it

for me" 的一种方式也许会帮助你理解 templatized inheritance（模板化继承）在做些什么。

像 NewHandlerSupport 这样的 templates 使得为任何有需要的 class 添加一个 class-specific new-handler 变得易如反掌。然而，mixin-style

inheritance（混合风格继承）总是会导致 multiple inheritance（多继承）的话题，而在我们沿着这条路走下去之前，你需要阅读 Item 40。

直到 1993 年，C++ 还要求 operator new 不能分配被请求的内存时要返回 null。operator new 现在则被指定抛出一个 bad_alloc exception，但是很多

C++ 程序是在编译器开始支持这个修订标准之前写成的。C++ 标准化委员会不想遗弃这些 test-for-null（检验是否为 null）的代码基础，所以他们提供

了 operator new 的另一种可选形式，用以提供传统的 failure-yields-null（失败导致 null）的行为。这些形式被称为 "nothrow" 形式，这在一定程度

上是因为它们在使用 new 的地方使用了 nothrow objects（定义在头文件中）：

class Widget { ... };
Widget *pw1 = new Widget; // throws bad_alloc if
// allocation fails

if (pw1 == 0) ... // this test must fail

Widget *pw2 =new (std::nothrow) Widget; // returns 0 if allocation for
// the Widget fails

if (pw2 == 0) ... // this test may succeed

对于异常，nothrow new 提供了比最初看上去更少的强制保证。在表达式 "new (std::nothrow) Widget" 中，发生了两件事。首先，operator new 的

nothrow 版本被调用来为一个 Widget object 分配足够的内存。如果这个分配失败，众所周知，operator new 返回 null pointer。然而，如果它成功了

，Widget constructor 被调用，而在此刻，所有打的赌都失效了。Widget constructor 能做任何它想做的事。它可能自己 new 出来一些内存，而如果它

这样做了，它并没有被强迫使用 nothrow new。那么，虽然在 "new (std::nothrow) Widget" 中调用的 operator new 不会抛出，Widget constructor 却

可以。如果它这样做了，

effective C++: 8.定制new和delete(三)