1.對於C++而言，malloc是函式，但是new是運算子

看似函式和運算子實現的功能都差不多。但是對於C++來說，new是運算子就意味著我們可以進行運算子過載，這就意味著我們可以定製我們自己的new記憶體分配器。
同時，由於C++特有的異常處理機制，我們不但可以在我們記憶體分配失敗的時候，new返回一個null，同時也可以報出一個bad_alloc錯誤，同時呼叫我們的new_handler（new運算子錯誤處理程式），但是我們的new_handler應該如何寫呢。
還是先來一段程式碼：

class NewHandlerHolder
{
public:
    explicit NewHandlerHolder(std
 
::new_handler nh):handler(nh)  //取得目前的new-handler.釋放它
    ~NewHandlerHolder()
    {std::set_new_handler(handler); }
private:
    std::new_handler handler;           //記錄下來,阻止copying
    NewHandlerHolder(const NewHandlerHolder&);  
    NewHandlerHolder& operator=(const NewHandlerHolder&);
};

void
 
* Widget::operator new(std::size_t size) throw(std::bad_alloc)
{
    NewHandlerHolder h(std::set_new_handler(currentHandler));   //安裝Widget的new-handler.
    return ::operator new(size);                    //分配記憶體或丟擲異常.恢復global new-handler.
}

template<typename T>    //"mixin"風格的base class,用以支援
//class 專屬的set_new_handler
 

class NewHandlerSupport
{
public:
    static std::new_handler set_new_handler(std::new_handler p)throw();
    static void* operator new(std::size_t size) throw(std::bad_alloc);
private:
    static std::new_handler currentHandler;
};

template<typename T>
std::new_handler NewHandlerSupport<T>::set_new_handler(std::new_handler p) throw()
{
    std::new_handler oldHandler=currentHandler;
    currentHandler=p;
    return oldHandler;
}
template<typename T>
void* NewHandlerSupport<T>::operator new(std::size_t size) throw(std::bad_alloc)
{
    NewHandlerHolder h(std::set_new_handler(currentHandler));
    return ::operator new(size);
}
//以下將每一個currentHandler初始化為null
template<typename T>
std::new_handler NewHandlerSupport<T>::currentHandler=0;

上面的程式碼，將我們過載的New以及new_handler函式封裝成了一個類使用。但是，這裡要注意的是，如果我們多重繼承這個NewHandler類，要看適不適合我們的類，否則將會出現錯誤。

2.對於C++而言，new運算子可以動態申請我們的一個物件的空間

這裡，我還是以一個例子來說明new來動態申請我們的一個物件的空間會引發什麼問題：

Example* em=new Example

我們申請一個Example類的物件的時候，一共做了兩件事：
1.類似malloc的過程申請了一塊空間。
2.呼叫Example類的建構函式。
但是如果在第二步的時候，程式丟擲了異常。那麼是不是代表著new的過程失敗了，丟擲一異常，返回了null。第一步申請的空間還是申請，但沒有得到指標進行delete操作，這就造成了記憶體洩露。
這明顯是我們不想看到的不可控的情況。
實際上解決這個問題的方法也有兩種：
1.對記憶體塊進行簽名。
2.我們每一次new的過程中都要返回一個指向空間的指標就行了。
實際上，我們的C++的new庫已經為我們實現了這個功能：

#include<new>
void* operator new(std::size_t,void* pMemory) throw()

那個pMemory就是指向我們空間的指標啦，這樣即使出現剛剛的情況，我們也可以利用這個指標來進行返回。
還有一種是基於簽名的方式，這裡還是直接上程式碼：

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);     //增加大小，使能夠塞入兩個signatures.
    void* pMem=malloc(realSize);            //呼叫malloc取得記憶體。
    if(!pMem) throw bad_alloc();

    //將signature寫入記憶體的最前段落和最後段落
    //減一個int是為了能夠寫在這個int的地方寫上簽名
    *(static_case<int*>(pMem))=signature;
    *(reinterpret_case<int*>(static_case<Byte*>(pMem)+realSize-sizeof(int)))=signature;

    //返回指標，指向恰位於第一個signature之後的記憶體位置.
    return static_cast<Byte*>(pMem)+sizeof(int);
}

可以從程式碼看出，主要做的改動就是把原來申請的空間擴充套件了兩個int的簽名，然後頭尾加上簽名，之後返回的是第一個簽名後的記憶體位置。
但是這樣做可能無法實現的記憶體對齊的要求（記憶體對齊是為了更快的訪問（直接通過記憶體的移位操作進行訪問））。
既然提到了記憶體對齊的問題，這裡就要提一下一個優秀的記憶體分配器應該考慮什麼，我們考慮個性化的記憶體分配器應該考慮什麼？

3.優秀的記憶體分配器應該如何設計考慮

記憶體分配器的具體設計在我的另一篇部落格上有提到：
http://blog.csdn.net/github_33873969/article/details/78571868
這裡我們更專注記憶體分配器的其他方面：
1.執行緒安全(在多執行緒環境下，我們的new過程還是否安全)
2.檔案系統的記憶體對齊問題
3.對於使用記憶體情況的統計問題
4.為了將相關物件成簇集中
這裡我們簡單的提幾點
1.為了保證執行緒安全的時候，我們在new的時候如果對連結串列進行操作需要對連結串列的結點利用鎖機制進行保護。但是這樣就會降低一定量的效果。這就給我們定製new做了一個要求，要在只有單執行緒的環境下把相關鎖關掉。
3.關於使用記憶體情況的統計問題，我們可以在我們的new的過程中，統計我們申請的塊的大小情況，回收與申請的時間間隔如何，他們更傾向於FIFO次序或LIFO（後進先出）次序，之後我們可以再進行合理化定製。
4.為了將相關物件成簇集中。為了考慮區域性性原理，我們可以將相同的物件放在一起，為了能夠得到cache親和，來進行快速訪問。
Reference：Effective C++ （改善程式與設計的55個具體做法）