條款52：寫了placement new也要寫palcement delete

問題：

Widget* pw=new Widget;

這條語句的執行導致兩個函式被使用：一個是用以分配記憶體的operator new，另一個是Widget的default建構函式。假設其中第一個函式呼叫成功，第二個函式丟擲異常。這樣第一步中operator new的記憶體分配所得必須取消並恢復舊觀，否則會造成記憶體洩漏，這個時候，客戶沒有能力歸還記憶體，因為如果Widget建構函式丟擲異常，pw當前尚未被賦值，客戶手上就沒有相應的指標執行指向該被歸還的記憶體，取消第一步並恢復舊觀的重任就變成了C++執行期系統的重任。

執行期系統會呼叫第一步中operator new的相應operator delete版本，前提是它必須知道哪一個operator delete被呼叫：

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

然而當我們宣告一個非正常形式的operator new，也就是帶有附加引數的operator new時，那麼該呼叫那個operator delete呢？

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

};

1、placement new/delete的提出

如果operator new接受的引數除了一定會有的那個size_t之外還有其他，這便是所謂的placement new，眾多的placement new版本中有一個“接受一個指標指向物件該被構造之處”，這種placement new已經被納入C++標準程式庫，呼叫#include <new>就可以取用它。這種operator new的樣子如下所示：

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

上面我們針對Widget已經聲明瞭一種placement new版本，如何使用它呢？下面舉一個例子便於大家理解：

Widget* pw=new (std::cerr)Widget;//呼叫operator new並傳遞cerr作為其ostream實參，這個動作會在Widget建構函式丟擲異常時洩漏記憶體

那麼此時如果丟擲異常的話怎樣取消operator new的分配並恢復舊觀，由於執行期間系統無法知道真正被呼叫的那個operator new如何運作，因此它無法取消分配並恢復舊觀，取而代之得失C++執行期系統尋找“引數個數和型別都與operator new相同的”operator delete。如果找到，就是它的呼叫物件。那麼Widget的這種形式的operator new對應的operator delete版本應該是：

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

這也就引出了placement delete的定義，如果operator delete如果接受額外引數，便稱為placement delete。

下面我們寫一個class專屬的operator new，要求接受一個ostream，用來志記相關分配資訊，同時又洗了一個正常形式的class專屬operator delete：

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();
    ...
};

2、placement 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
class Derived:public Base{
public: 
    ...
    static void* operator new(std::size_t size);
    ...
};
Derived* pd=new (std::clog)Derived;//錯誤，因為Base中的placement new被遮掩了
Derived* pd=new Derived;//正確

要解決遮掩問題的話，我們需要家裡一個Base class，內含所有正常形式的new和delete：

class StandardNewDeleteForms{
public: 
    static void* operator new(std::size_t size) throw(std::bad_alloc){
        return ::operator new(size);
    }
    static void opearator 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);
    }
    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&nt) throw(){
        ::operator delete(pMemory);
    }
};  
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);
    static void operator delete(void* pMemory,std::ostream& logStream)throw();
    ...
};

PS:
C++中operator new/delete或者operator new[]/delete[]的解析方式：http://blog.csdn.net/hazir/article/details/21413833
總結：
1）當你寫了一個placement operator new，請確定也謝了對應的placement operator delete，如果沒有這樣做，程式可能會發生隱蔽而時斷時續的記憶體洩漏；
2）當你聲明瞭placement new和placement delete，請確定不要無意識地遮掩了它們的正常版本。