52：写了placement new也要写placement delete

当你写一个new表达式像这样：

 Widget* pw = new Widget;

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

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

取消步骤一并恢复旧观的责任因此落到C++运行期系统身上。

运行期系统会高高兴兴地调用步骤一所调用的opeator new的相应operator delete版本，前提当然是它必须知道哪一个（因为可能有多个）operator delete该被调用。

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

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

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

这个设计有问题，但在探讨原因之前，先来讨论若干术语。

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

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

这个版本的new已被纳入C++标准程序库，你只要#include <new>就可以取用它。

这个new的用途之一是负责在vector的未使用空间上创建对象。它同时也是最早的placement new版本。实际上它正是这个函数的命名根据：一个特定位置上的new。以上说明意味术语placement new有多重定义。当人们谈到placement new，大多时候他们谈的是此一特定版本，也就是“唯一额外实参是个void*”，少数时候才是指接受任意额外实参的operator new。

现在回到Widget class的声明式。这里的技术困难在于，这个class将引起微妙的内存泄漏。考虑以下客户代码，它们在动态创建一个Widget时将相关的分配信息志记于cerr：

    //调用operator new并传递cerr为其ostream实参，
    //这个动作会在Widget构造函数抛出异常时泄漏内存
    Widget* pw = new (std::cerr) 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 delete。现在，既然Widget没有声明placement版本的operator delete，所以运行期系统不知道如何取消并恢复原先对placement new的调用。于是什么也不做。本例中若Widget构造函数抛出异常，不会走任何operator delete被调用（那当然不妙）。

规则很简单：若一个带额外参数的operator new没有“带相同额外参数”的对应版operator delete，那么当new的内存分配动作需要取消并恢复旧观时就没有任何operator delete会被调用。因此，为了消弭稍早代码中的内存泄漏，Widget有必要声明一个placement delete，对应于那个有志记功能的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();
    void operator delete(void* pMemory, std::ostream&) 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一样。

由于成员函数的名称会掩盖其外围作用域中的相同名称，你必须小心避让class专属的new掩盖客户期望的其他new（包括正常版本）。

假设你有一个base class，其中声明唯一一个placement operator new，客户端会发现他们无法使用正常形式的new：

class Base {
public:
    //...
    //这个new会遮掩正常的global形式
    static void* operator new(std::size_t size,
        std::ostream& logStream) throw(std::bad_alloc);
    //...
};
//错误，因为正常形式的operator new被掩盖
Base* pb = new Base;
//正确，调用Base的placement new
Base* pb = new (std::cerr) Base;

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

class Derived : public Base {//继承自先前的Base
public:
    //...
    //重新声明正常形式的new
    static void* operator new(std::size_t size) throw(std::bad_alloc);
    //...
};
//错误，因为Base的placement new被掩盖了
Derived* pd = new (std::cerr) Derived;
//没问题，调用Derived的operator new
Derived* pd = new Derived;

对于撰写内存分配函数，你需要记住的是，缺省条件下C++会在global作用域内提供以下形式的operstor new：

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

若你在class内声明任何operator new，它会遮掩上述这些标准形式。除非你的意思就是要阻止class的客户使用这些形式，否则请确保它们在你所生成的任何定制型operator new之外还可用。对于每一个可用的operator new也请确定提供对应的operator delete。

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

class StandardNewDeleteForms {
public:
    //normal new/delete
    static void* operator new(std::size_t size) throw(std::bad_alloc)
    {
        return ::operator 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()
    {
        ::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声明式取得标准形式：

//继承标准形式
class Widget : public StandardNewDeleteForms {
public:
    //让这些形式可见
    using StandardNewDeleteForms::operator new;
    using StandardNewDeleteForms::operator delete;
    //添加一个自定的placement
    static void* operator new(std::size_t size,
        std::ostream& logStream) throw(std::bad_alloc);
    //添加一个对应的placement delete
    static void operator delete(void* pMemory,
        std::ostream& logStrea) throw();
    //...
};

总结

1.当你写一个placement operator new，请确定也写出了对应的placement operator delete。若没有这样做，你的程序可能会发生隐微而时断时续的内存泄漏。

2.当你声明placement new和placement delete，请确定不要无意识地遮掩了它们的正常版本。