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

        placement new和placement delete并非C++兽栏中最常见的动物，如果你不熟悉它们，不要感到挫折或忧虑。回忆条款16和17，当你写一个new表达式像这样：

Widget* pw = new Widget;

共有两个函数被调用：一个是用以分配内存的operator new，一个是Widget的default构造函数。

        假设其中第一个函数调用成功，第二个函数却抛出异常。既然这样，步骤一的内存分配所得必须取消并恢复旧观，否则会造成内存泄漏。在这个时候，客户没有能力归还内存，因为如果Widget构造函数抛出异常，pw尚未被赋值，客户手上也就没有指针指向该被归还的内存。取消步骤一并恢复旧观的责任因此落到C++运行期系统身上。

        运行期心态会调用步骤一所调用的operator new相应operator delete版本，前提当然是它必须知道哪一个（因为可能有许多个）operator delete该被调用。如果目前面对的是拥有正常签名式的new和delete，这并不是问题，因为正常的operator new：

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

对应正常的operator delete：

void operator delete(void* rawMemory) throw();  // global作用域中的正常签名式
void operator delete(void* rawMemory, std::size_t size) throw();  // class作用域中典型的签名式

        因此，当你只使用正常形式的new和delete，运行期系统毫无问题可以找出那个“知道如何取消new所作所为并恢复旧观”的delete。然而当你开始声明非正常形式的operator new，也就是带有附加参数的operator new，“究竟哪一个delete伴随这个new”的问题便浮现了。

        例如，假设你写了一个class专属的operator new，要求接受一个ostream用来记录（logged）相关分配信息，同时又写了一个正常形式的class专属operator delete：

class Widget {
public:
    ...
    static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);  // 非正常形式的new
    static void operator delete(void* pMemory std::size_t size) throw();  // 正常的class专属delete
}

        这个设计有问题，但在探讨原因之前，我们需要先绕道，扼要讨论若干术语。

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

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

        这个版本的new已被纳入C++标准程序库，你只要#include<new>就可以取用它。这个new的用途之一是负责在vector的未使用空间上创建对象。它同时也是最早的placement new版本。实际上它正是这个函数的命名根据：一个特定位置上的new。以上说明意味术语placement new有多重定义。当人们谈到placement new，大多数时候他们谈的是此一特定版本，也就是“唯一额外实参是个void*”，少数时候才是指接受任意额外实参之operator new。上下文语境往往也能够使意义不明确的含糊话语清晰起来，但了解这一点相当重要：一般性术语“placement new”意味带任意额外参数的new，因为另一个术语“placement delete”直接派生自它。稍后我们即将遭遇后者。

        现在让我们回到Widget class的声明式，也就是先前我说设计有问题的那个。这里的技术困难在于，那个class将引起微妙的内存泄漏。考虑以下客户代码，它在动态创建一个Widget时将相关的分配信息记录（logs）于cerr：

Widget* pw = new (std::cerr) Widget;  // 调用operator new并传递cerr为其ostream实参；这个动作会在Widget构造函数中抛出异常时泄漏内存

        如果内存分配成功，而Widget构造函数抛出异常，运行期系统有责任取消operator new的分配并恢复旧观。然而运行期系统无法知道真正被调用的那个operator new如何运作，因此它无法取消分配并恢复旧观，所以上述做法行不通。取而代之的是，运行期系统寻找“参数个数和类型都与operator new相同”的某个operator delete。如果找到，那就是它的调用对象。既然这里的operator new接受类型为ostream&的额外实参，所以对应的operator delete就应该是：

void operator delete(void*, std::ostream&) throw();

        类似于new的placement版本，operator delete如果接受额外参数，便称为placement deletes。现在，既然Widget没有声明placement 版本的operator delete，所以运行期系统不知道如何取消并恢复原先对placement new的调用。于是什么也不做。本例之中如果Widget构造函数抛出异常，不会有任何operator delete被调用（那当然不妙）。

        规则很简单：如果一个带额外参数的operator new没有“带相同额外参数”的对应版operator delete，为了消弭稍早代码中的内存泄漏，Widget有必要声明一个placement delete，对应于那个有日志功能（logging）的placement new：

class Widget {
public:
    ...
    static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
    static void operator delete(void* pMemory) throw();
    static void operator delete(void* pMemory, std::ostream& logStream) throw();
    ...
};

        这样改变之后，如果以下语句引发Widget构造函数抛出异常：

Widget* pw = new (std::cerr) Widget; // 一如既往，但这次不再泄漏

对应的placement delete会被自动调用，让Widget有机会确保不泄露任何内存。

        然而如果没有抛出异常（通常如此），而客户代码中有个对应的delete，会发生什么事：

delete pw;  // 调用正常的operator delete

        就如上一行注释所言，调用的是正常形式的operator delete，而非其placement版本。placement delete只有在“伴随placement new调用而触发的构造函数”出现异常时才会被调用。对着一个指针（例如上述的pw）施行delete绝不会导致调用placement delete。不，绝对不会。

        这意味如果要对所有与placement new相关的内存泄漏宣战，我们必须同时提供一个正常的operator delete（用于构造期间无任何异常抛出）和一个placement版本（用于构造期间有异常被抛出）。后者的额外参数必须和operator new一样。只要这样做，你就再也不会因为难以察觉的内存泄漏而失眠。

        由于成员函数名称会掩盖其外围作用域中的相同名称（见条款33），你必须小心避免让class专属的news掩盖客户期望的其他news（包括正常版本）。假设你有一个base class，其中声明唯一一个placement operator new，客户端会发现无法正常使用正常形式的new：

class Base {
public:
    ...
    static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc); // 这个new会遮掩正常的global形式
    ...
};
​

Base* pb = new Base;               // 错误！因为正常形式的operator new被掩盖
Base* pb = new (std::cerr) Base;   // 正确，调用Base的placement new.

        同样道理，derived classes中的operator news会掩盖global版本和继承而得的operator new版本：

class Derived: public Base {
public:
    ...
    static void* operator new(std::size_t size) throw(std::bad_alloc); // 重新声明正常形式的new
    ...
};

Derived* pd = new (std::clog) Derived;  // 错误！因为Base的placement new被掩盖了.
Derived* pd = new Derived;              // 没问题，调用Derived的operator new.

        条款33更详细地讨论了这种名称遮掩问题。对于撰写内存分配函数，你需要记住的是，缺省情况下C++在global作用域内提供以下形式的operator new：

void* operator new(std::size_t) throw(std::bad_alloc);  // normal new.
void* operator new(std::size_t, void*) throw();  // placement new.
void* operator new(std::size_t, const std::nothrow_t&) throw();  // nothrow new.

        如果你在class内声明任何operator news，它会遮掩上述这些标准形式。除非你的意思就是要阻止class的客户使用这些形式，否则请确保它们在你所生产的任何定制型operator new之外还可用。对于每一个可用的operator new也请确定提供对应的operator delete。如果你希望这些函数有着平常的行为，只要令你的class专属版本调用global版本即可。

        完成以上所言的一个简单做法是，建立一个base class，内含所有正常形式的new和delete：

class StandardNewDeleteForms {
public:
    // normal new/delete
    static void* operator new(std::size_t size) throw(std::bad_alloc)
    { return ::operaotr new(size); }
    static void operator delete(void* pMemory) throw()
    { ::operator delete(pMemory); }

    // placement new/delete
    static void* operator new(std::size_t size, void* ptr) throw()
    { return ::operator new(size, ptr); }
    static void operator delete(void* pMemory, void* ptr) throw()
    { return ::operator delete(pMemory, ptr); }

    // nothrow new/delete
    static void* operator new(std::size_t size, const std::nothrow_t& nt) throw()
    { return ::operator new(size, nt); }
    static void operator delete(void* pMemory, const std::nothrow_t&) throw()
    { ::operator delete(pMemory); }
};

        凡是想以自定形式扩充标准形式的客户，可利用继承机制及using声明式（见条款33）取得标准形式：

class Widget: public StandardNewDeleteForms {
public:
    using StandardNewDeleteForms::operator new;
    using StandardNewDeleteForms::operator delete;
    static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);  //添加自定义的placement new
    static void operator delete(void* pMemory, std::ostream& logStream) throw();  //添加自定义的placement delete
    ...
};

请记住

• 当你写一个placement operator new，请确定也写出了对应的placement operator delete。如果没有这样做，你的程序可能会发生隐微而时断时续的内存泄漏。
• 当你声明placement new和placement delete，请确定不要无意识（非故意）地遮掩了它们的正常版本。