BOOK

namespace std {
    typedef void (*new_handler) ( );
    new_handler set_new_handler(new_handler p) throw();
}

void outOfMem() {
    std::cerr << "Unable to satisfy request for memory\n";
    std::abort();
}

int main() {
    std::set_new_handler(outOfMem);
    int* pBigDataArray = new int[100000000L];
    ...
}

• 讓更多記憶體可被使用：
• 安裝另一個 new-handler：
• 卸除 new-handler：
• 拋出 bad_alloc (或衍生自 bad_alloc 的) exception：
• 不回返：

class Widget { ... };
Widget* pw1 = new Widget;  // 若配置失敗，拋出 bad_alloc
if (pw1 == NULL) ...  // 這個測試一定失敗
Widget* pw2 = new (std::nothrow) Widget;  // 若配置 Widget 失敗，傳回 NULL
if (pw2 == NULL) ...  // 這個測試可能成功

• 用來檢測運用上的錯誤：如果將「new 所得記憶體」 delete 失敗，會導致 memory leaks，若 delete 多次，則導致不確定從為；此外，若編程錯誤將導致資料 "overruns" 或 "underruns"；如果可以自行定義 operator new 及 delete，便可配置超額記憶體，以額外空間放置特定的 byte pattern，而在 delete 時，得以檢查 byte pattern 是否原封不動，以判斷是否有 "overruns" 或 "underruns" 的情況發生。
• 為了強化效能：compiler 所帶的 operator new 及 delete 主要用於一般目的，處理需求包含大塊記憶體、小塊記憶體、大小混合記憶體，但不對特定項目有最佳表現，所以如果對程式的動態記憶體運用型態有深測瞭解的話，通常可以發現，自定版本的 operator new 及 delete 性能會勝過預設版本。
• 為了收集使用上的統計數據：在自訂義 operator new 及 delete 之前，理當先收集軟體如何使用其動態記憶體，配置區塊的大小分佈如何？壽命分佈如何？及其它相關資訊等。

static const int signature = 0xDEADBEEF;
typedef unsigned char Byte;

void* operator new(std::size_t size) throw(std::bad_alloc) {
    using namespace std;
    size_t realSize = size + 2 * sizeof(int);  // 增加兩個 int

    void* pMem = malloc(realSize);  // 呼叫 malloc 取得 memory
    if (!pMem) throw bad_alloc();

    *(static_cast(pMem)) = signature;  // 塞入 signature
    *(reinterpret_cast(static_cast(pMem)+realSize-sizeof(int))) = 
            signature;

    return static_cast(pMem) + sizeof(int);
}

• 為了檢測運用錯誤：
• 為了蒐集動態配置記憶體之使用統計資訊：
• 為了增加配置和歸還的速度：
• 為了降低預設記憶體管理器帶來的空間額外開銷：
• 為了彌補預設配置器中的 suboptimal alignment：
• 為了相相關物件成簇集中：
• 為了獲得非傳統的行為：

void* operator new(std::size_t size) throw(std::bad_alloc) {
    using namespace std;
    if (size == 0) {
        size = 1;
    }

    while (true) {
        if (配置成功)
            return (a pointer，指向配置來的 memory);
        // 配置失敗：找出目前的 new-handling function
        // 就 multi-thread 而言，還需加上 lock 保護
        new_handler globalHandler = set_new_handler(0);
        set_new_handler(globalHandler);

        if (globalHandler) (*globalHandler) ();
        else throw std::bad_alloc();
    }
}

class Base {
  public:
    static void* operator new(std::size_t size) throw(std::bad_alloc);
    ...
};
class Derived : public Base {  // 若 Derived 未宣告 operator new
    ...
};
Derived* p = new Derived;  // 這裡呼叫的是 Base::operator new

void* Base::operator new(std::size_t size) throw(std::bad_alloc) {
    if (size != sizeof(Base))  // 如果 size 錯誤，令標準的
        return ::operator new(size);  // operator new 處理
    ...
}

void operator delete(void *rawMemory) throw() {
    // 如果是 null pointer，則 do nothing
    if (rawMemory == 0) return;

    // 現在，歸還 rawMemory 所指的 memory
}

class Base {
  public:
    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;
    if (size != sizeof(Base)) {
        ::operator delete(rawMemory);
        return;
    }
    // 歸還 rawMemory 所指的 memory
    return;
}

Widget* pw = new Widget;

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

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();  // 正常形式的 delete
    ...
};

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

Widget* pw = new (std::cerr) Widget;
// 呼叫 operator new 並傳遞 cerr 為其 ostream 引數，
// 會在 Widget constructor 拋出 exception 時造成 memory leak

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

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();  // 正常形式的 delete
    static void operator delete(void* pMemory std::size_t size,
            std::ostream& logStream) throw();
    // 非正常形式的 delete
    ...
};

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

Base* pb = new Base;  // 錯誤，正式型式的 operator new 被遮掩
Base* pb = new (std::cerr) Base;  // 正確

class Derived : public Base {
  public:
    ...
    static void* operator new(std::size_t size, std::ostream& logStream)
            throw(std::bad_alloc);  // 重新宣告正常型式的 new
    ...
};

Derived* pd = new (std::clog) Derived;
// 錯誤，Base 的 placement new 被遮掩了
Derived* pd = new Derived;  // 正確

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

class Widget : public StandardNewDeleteForms {
  public:
    // 讓這些型式可見
    using StandardNewDeleteForms::operator new;
    using StandardNewDeleteForms::operator delete;
    // 添加一個自定的 placement new
    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& logStream) throw();
   ...
};