# Item 51: 编写 new 和 delete 时要遵守惯例
作者：[Scott Meyers](http://aristeia.com/)
译者：[fatalerror99 (iTePub's Nirvana)](mailto:fatalerror9999@hotmail.com?subject=Item%2049)
发布：[http://blog.csdn.net/fatalerror99/](http://blog.csdn.net/fatalerror99/)
[Item 50](http://blog.csdn.net/fatalerror99/archive/2006/12/26/1463166.aspx) 讲解了什么时候你可能需要编写 operator new 和 operator delete 的你自己的版本，但是没有讲解当你这样做时必须遵循的惯例。这些规则并不难以遵循，但有一些不那么直观，所以了解它们是什么非常重要。
我们从 operator new 开始。实现一个符合惯例的 operator new 需要有正确的返回值，在没有足够的内存可用时调用 new-handling function（参见 [Item 49](http://blog.csdn.net/fatalerror99/archive/2006/02/28/612673.aspx)），并做好应付无内存请求的准备。你还要避免无意中对 new 的“常规”形式的覆盖，虽然这更多的是一个 class interface（类接口）的问题，而并非是一个实现的需求，它将在 [Item 52](http://blog.csdn.net/fatalerror99/archive/2007/01/21/1489466.aspx) 讨论。
operator new 的返回值部分很容易。如果你能提供所请求的内存，你就返回一个指向它的指针。如果你不能，你应该遵循 [Item 49](http://blog.csdn.net/fatalerror99/archive/2006/02/28/612673.aspx) 描述的规则并抛出一个 bad_alloc 类型的 exception（异常）。
然而，它也不完全那么简单，因为 operator new 实际上不止一次设法分配内存，每次失败后调用 new-handling function。在此假设 new-handling function 能做些事情释放一些内存。只有当指向 new-handling function 的指针为空时，operator new 才抛出一个 exception（异常）。
奇怪的是，C++ 要求即使请求零字节，operator new 也要返回一个合理的指针。（需要这种怪异的行为来简化语言的其它部分。）在这种情况下，一个 non-member（非成员）的 operator new 的伪代码如下：
```
void * operator new(std::size_t size) throw(std::bad_alloc)
{ // your operator new might
using namespace std; // take additional params
if (size == 0) { // handle 0-byte requests
size = 1; // by treating them as
} // 1-byte requests
while (true) {
_attempt to allocate size bytes;_
if (_the allocation was successful_)
return (_a pointer to the memory_);
// allocation was unsuccessful; find out what the
// current new-handling function is (see below)
new_handler globalHandler = set_new_handler(0);
set_new_handler(globalHandler);
if (globalHandler) (*globalHandler)();
else throw std::bad_alloc();
}
}
```
将零字节请求当作他们真的请求了一个字节来处理的窍门看起来很龌龊，但是它简单，合法，有效，无论如何，你估摸着的请求零字节这种事情发生的频率有多大呢？
你可能在不经意中还看到伪代码中将 new-handling function pointer 设置为空，然后又马上重置为它原来的值。遗憾的是，没有办法直接得到 new-handling function pointer，所以你必须调用 set_new_handler 以得知它是什么。拙劣，的确，但是也有效，至少对 single-threaded（单线程）代码没问题。在 multithreaded（多线程）环境中，你可能需要某种锁以便安全地摆布隐藏在 new-handling function 后面的（全局的）data structures（数据结构）。
[Item 49](http://blog.csdn.net/fatalerror99/archive/2006/02/28/612673.aspx) 谈及 operator new 包含一个无限循环，而上面的代码明确地展示了这个循环，"while (true)" 差不多会尽其所能地无限做下去。跳出循环的唯一出路是内存被成功分配或 new-handling function 做了 [Item 49](http://blog.csdn.net/fatalerror99/archive/2006/02/28/612673.aspx) 中描述的事情之一：使得更多的内存可用，安装一个不同的 new-handler，卸载 new-handler，抛出一个 bad_alloc 或从 bad_alloc 派生的 exception（异常），或不再返回。现在，new-handler 为什么要做这些事情之一已经很清楚了。如果它不这样做，operator new 内的循环永远不会停止。
很多人没有意识到 operator new member functions（成员函数）会被 derived classes（派生类）继承。这会引起一些有趣的复杂性。在前面的 operator new 伪代码中，注意那个函数设法分配 size 个字节（除非 size 是零）。因为它是传递给这个函数的 argument（实参），所以它有着明确的意义。然而，就像 [Item 50](http://blog.csdn.net/fatalerror99/archive/2006/12/26/1463166.aspx) 所讲的，编写一个自定义的内存管理器的最常见的原因之一是为了优化某个特定 class 的 objects 的分配，而不是某个 class 或它的任何 derived classes（派生类）的。也就是说，给定一个 class X 的 operator new，这个函数的行为通常是为大小为 sizeof(X) 的 objects 调谐的——绝不会更大或者更小。然而，由于 inheritance（继承），就有可能一个 base class（基类）中的 operator new 被调用来为一个 derived class（派生类）的 object 分配内存：
```
class Base {
public:
**static void * operator new(std::size_t size) throw(std::bad_alloc)**;
...
};
class Derived: public Base // Derived doesn't declare
{ ... }; // operator new
Derived *p = **new Derived**; // calls Base::operator new!
```
如果 Base 的 class-specific（类专用）的 operator new 不是被设计成应付这种情况的——它很可能不是——它处理这种局面的最佳办法就是把这个请求“错误”内存量的调用甩给 standard operator new，就像这样：
```
void * Base::operator new(std::size_t size) throw(std::bad_alloc)
{
**if (size != sizeof(Base))** // if size is "wrong,"
**return ::operator new(size)**; // have standard operator
// new handle the request
... // otherwise handle
// the request here
}
```
“不许动！”我听到你喊，“你忘了检查 size 是零这种 pathological-but-nevertheless-possible（病态然而可能）的情况！”实际上，我没有，还有，当你大声抱怨的时候拜托不要使用连字符。测试依然在那，它只是与 size 和 sizeof(Base) 的比较合在了一起。C++ 工作在一些神秘的方式中，这些方式之一就是强制规定所有的独立 objects 都具有非零的大小（参见 [Item 39](http://blog.csdn.net/fatalerror99/archive/2005/11/22/535067.aspx)）。根据定义，sizeof(Base) 绝不会是零，所以如果 size 是零，请求将转发给 ::operator new，而以一种合理的方式处置这个请求就成为那个函数的职责。
如果你想要在每一个 class 的基础上控制数组的内存分配，你需要实现 operator new 的专用于数组的兄弟，operator new[]。（这个 function 通常被叫做 "array new"，因为要确定 "operator new[]" 如何发音实在是太难了。）如果你决定要编写 operator new[]，记住你所做的全部是分配一大块 raw memory（裸内存）——你不能针对还不存在的数组中的 objects 做任何事情。实际上，你甚至不能确定数组中会有多少个 objects。首先，你不知道每个 object 有多大。毕竟，一个 base class（基类）的 operator new[] 通过继承可以被调用来为一个 derived class objects（派生类对象）的数组分配内存，而 derived class objects（派生类对象）通常都比 base class objects（基类对象）更大。
因此，在 Base::operator new[] 中，你不能断定每一个加到数组中的 object 的大小一定是 sizeof(Base)，而这就意味着，你不能断定数组中的 objects 的数量是 (_bytes requested_)/sizeof(Base)。第二，传递给 operator new[] 的 size_t 参数可能比充满 objects 的内存还要大一些，因为，就像 [Item 16](http://blog.csdn.net/fatalerror99/archive/2005/07/20/430119.aspx) 讲到的，dynamically allocated arrays（动态分配数组）可能包括额外的空间用于存储数组元素的数量。
编写 operator new 时，你需要遵循的惯例也就到此为止了。对于 operator delete，事情就更简单了，你需要记住的全部大约就是 C++ 保证删除空指针总是安全的，所以你需要遵循这个保证。下面是一个非成员的 operator delete 的伪代码：
```
void operator delete(void *rawMemory) throw()
{
if (rawMemory == 0) return; // do nothing if the null
// pointer is being deleted
_deallocate the memory pointed to by rawMemory;_
}
```
这个函数的成员版本也很简单，只是你必须确保检查被删除东西的大小。假设你的 class-specific（类专用）的 operator new 将“错误”大小的请求转发给 ::operator new，你也可以将“错误大小”的删除请求转发给 ::operator delete：
```
class Base { // same as before, but now
public: // operator delete is declared
static void * operator new(std::size_t size) throw(std::bad_alloc);
**static void operator delete(void *rawMemory, std::size_t size) throw();**
...
};
void Base::operator delete(void *rawMemory, std::size_t size) throw()
{
if (rawMemory == 0) return; // check for null pointer
**if (size != sizeof(Base)) {** // if size is "wrong,"
**::operator delete(rawMemory);** // have standard operator
**return;** // delete handle the request
**}**
_deallocate the memory pointed to by rawMemory;_
return;
}
```
有趣的是，如果被删除的 object 是从一个缺少 virtual destructor（虚拟析构函数）的 base class（基类）派生出来的，C++ 传递给 operator delete 的 size_t 值也许是不正确的。这已经足够作为“确保你的 base classes（基类）拥有 virtual destructors（虚拟析构函数）”的原因了，除此之外，[Item 7](http://blog.csdn.net/fatalerror99/archive/2005/07/10/419235.aspx) 描述了另一个，论证得更好的原因。至于当前，简单地记住如果你在 base classes（基类）中遗漏了 virtual destructors（虚拟析构函数），operator delete functions 可能无法正确工作。
**Things to Remember**
* operator new 应该包含一个设法分配内存的无限循环，如果它不能满足一个内存请求，应该调用 new-handler，还应该处理零字节请求。class-specific（类专用）版本应该处理对比预期更大的区块的请求。
* operator delete 如果收到一个空指针应该什么都不做。class-specific（类专用）版本应该处理比预期更大的区块。
- Preface（前言）
- Introduction（导言）
- Terminology（术语）
- Item 1: 将 C++ 视为 federation of languages（语言联合体）
- Item 2: 用 consts, enums 和 inlines 取代 #defines
- Item 3: 只要可能就用 const
- Item 4: 确保 objects（对象）在使用前被初始化
- Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数
- Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝
- Item 7: 在 polymorphic base classes（多态基类）中将 destructors（析构函数）声明为 virtual（虚拟）
- Item 8: 防止因为 exceptions（异常）而离开 destructors（析构函数）
- Item 9: 绝不要在 construction（构造）或 destruction（析构）期间调用 virtual functions（虚拟函数）
- Item 10: 让 assignment operators（赋值运算符）返回一个 reference to *this（引向 *this 的引用）
- Item 11: 在 operator= 中处理 assignment to self（自赋值）
- Item 12: 拷贝一个对象的所有组成部分
- Item 13: 使用对象管理资源
- Item 14: 谨慎考虑资源管理类的拷贝行为
- Item 15: 在资源管理类中准备访问裸资源（raw resources）
- Item 16: 使用相同形式的 new 和 delete
- Item 17: 在一个独立的语句中将 new 出来的对象存入智能指针
- Item 18: 使接口易于正确使用，而难以错误使用
- Item 19: 视类设计为类型设计
- Item 20: 用 pass-by-reference-to-const（传引用给 const）取代 pass-by-value（传值）
- Item 21: 当你必须返回一个对象时不要试图返回一个引用
- Item 22: 将数据成员声明为 private
- Item 23: 用非成员非友元函数取代成员函数
- Item 24: 当类型转换应该用于所有参数时，声明为非成员函数
- Item 25: 考虑支持不抛异常的 swap
- Item 26: 只要有可能就推迟变量定义
- Item 27: 将强制转型减到最少
- Item 28: 避免返回对象内部构件的“句柄”
- Item 29: 争取异常安全（exception-safe）的代码
- Item 30: 理解 inline 化的介入和排除
- Item 31: 最小化文件之间的编译依赖
- Item 32: 确保 public inheritance 模拟 "is-a"
- Item 33: 避免覆盖（hiding）“通过继承得到的名字”
- Item 34: 区分 inheritance of interface（接口继承）和 inheritance of implementation（实现继承）
- Item 35: 考虑可选的 virtual functions（虚拟函数）的替代方法
- Item 36: 绝不要重定义一个 inherited non-virtual function（通过继承得到的非虚拟函数）
- Item 37: 绝不要重定义一个函数的 inherited default parameter value（通过继承得到的缺省参数值）
- Item 38: 通过 composition（复合）模拟 "has-a"（有一个）或 "is-implemented-in-terms-of"（是根据……实现的）
- Item 39: 谨慎使用 private inheritance（私有继承）
- Item 40: 谨慎使用 multiple inheritance（多继承）
- Item 41: 理解 implicit interfaces（隐式接口）和 compile-time polymorphism（编译期多态）
- Item 42: 理解 typename 的两个含义
- Item 43: 了解如何访问 templatized base classes（模板化基类）中的名字
- Item 44: 从 templates（模板）中分离出 parameter-independent（参数无关）的代码
- Item 45: 用 member function templates（成员函数模板） 接受 "all compatible types"（“所有兼容类型”）
- Item 46: 需要 type conversions（类型转换）时在 templates（模板）内定义 non-member functions（非成员函数）
- Item 47: 为类型信息使用 traits classes（特征类）
- Item 48: 感受 template metaprogramming（模板元编程）
- Item 49: 了解 new-handler 的行为
- Item 50: 领会何时替换 new 和 delete 才有意义
- Item 51: 编写 new 和 delete 时要遵守惯例
- Item 52: 如果编写了 placement new，就要编写 placement delete
- 附录 A. 超越 Effective C++
- 附录 B. 第二和第三版之间的 Item 映射