內存分配(器)返回的是一塊沒有初始化的內存，不返回對象；內存分配(器)也不支持設置成虛指針，因為內存分配是在構造執行后；
1 void* raw = allocate(sizeof(Foo)); // line 1
2 Foo* p = new(raw) Foo(); // line 2
allocate就是一個簡單的內存分配(器)，上面的代碼使用了placement new來構造對象。
下面一步就是做一個對象的內存分配(器)-------------內存池(類)
1 class Pool {
2 public:
3 void* alloc(size_t nbytes);
4 void dealloc(void* p);
5 private:
6
data members used in your pool object
7 };
8
9 void* Pool::alloc(size_t nbytes)
10 {
11
your algorithm goes here
12 }
13
14 void Pool::dealloc(void* p)
15 {
16
your algorithm goes here
17 }
分配對象使用下面的代碼
1 Pool pool;
2
3 void* raw = pool.alloc(sizeof(Foo));
4 Foo* p = new(raw) Foo();
或者更簡單的代碼
Foo* p = new(pool.alloc(sizeof(Foo))) Foo();
這樣做的好處是可以使用N個內存池而不是共享一塊大內存，可以從內存池中分配而不用釋放，一次釋放整個內存池；也可以其中一部分做共享內存而不用系統的共享內存，從另一個角度來看，很多系統支持alloca()從stack中分配內存塊，當然這些內存塊也會自動離開在函數返回時，無須delete；當然也可以使用alloca()為(內存)池分配一個大內存塊，而無須調用delete，在這里析構函數僅僅只是（deallocates）釋放分配的內存。
下一步就是就是改變分配對象的語法：與其使用new(pool.alloc(sizeof(Foo)))
Foo() 倒不如new(pool)
Foo()，為此我們需要實現下面的函數：
inline void* operator new(size_t nbytes, Pool& pool)
{
return pool.alloc(nbytes);
}
現在看看這個new(pool)Foo(),它會調用operator new，通過sizeof(Foo)和pool兩個參量，下面看看如何析構對象和釋放內存，根據placement new的析構方法，代碼如下：
void sample(Pool& pool)
{
Foo* p = new(pool) Foo();
p->~Foo(); // explicitly call dtor
pool.dealloc(p); // explicitly release the memory
}
但這樣做，會有下面幾個問題產生：
問題一：防止內存泄露，在Foo* p = new Foo()，編譯器會產生類似下面的代碼來應對構造中的異常
// This is functionally what happens with Foo* p = new Foo()
Foo* p;
// don't catch exceptions thrown by the allocator itself
void* raw = operator new(sizeof(Foo));
// catch any exceptions thrown by the ctor
try {
p = new(raw) Foo(); // call the ctor with raw as this
}
catch (
) {
// oops, ctor threw an exception
operator delete(raw);
throw; // rethrow the ctor's exception
}
問題是在deallocates(去分配)內存時如發生異常，具體的說就是new的參數(調用placement(布局) new)時出現異常，此時編譯器不知所措，默認就什么都不做。
// This is functionally what happens with Foo* p = new(pool) Foo():
void* raw = operator new(sizeof(Foo), pool);
// the above function simply returns "pool.alloc(sizeof(Foo))"
Foo* p = new(raw) Foo();
// if the above line "throws", pool.dealloc(raw) is NOT called
所以編譯器要做一些類似于全局new operator的工作，當編譯器看到
new(pool) Foo()，它要查找與之想匹配的delete operator，如果找到了，就相當于上面顯示
的包含try的代碼可以正確執行，所以要寫個delete operator，像下面的代碼所示（即使第二參數和operator new(size_t, Pool&)中的第二個參數不同，也沒有關系，編譯器也
不會有什么抱怨，此時它會繞過這個try塊）
void operator delete(void* p, Pool& pool)
{
pool.dealloc(p);
}
注意：這個operator delete不必一定是inline的，可以是，也可以不是。
destruction（析構）/deallocation(去分配)是兩個不同的概念，可現實中經常混淆這兩個；另外要記住內存池里的內存和哪個對象匹配，一般我們通過Foo *和
pool* 這兩個指針來定位；對于這兩個方面可能出現的問題，可以用下面的方案來解決。
這個方案就是使每次分配(對象)都關聯一個pool *，然后在替代全局delete opeator，如下所示：
void operator delete(void* p)
{
if (p != NULL) {
Pool* pool = /* somehow get the associated 'Pool*' */;
if (pool == null)
free(p);
else
void* operator new(size_t nbytes)
{
if (nbytes == 0)
nbytes = 1; // so all alloc's get a distinct address
void* raw = malloc(nbytes);
somehow associate the NULL 'Pool*' with 'raw'
return raw;
}
pool->dealloc(p);
}
如果不確信dealloc調用free，可以在全局的new operator中使用malloc(),像下面的代碼所示(此短代碼沒有throw std::bad_alloc()new_handler)
下面的工作就是用pool*關聯每次 allocation(分配)，這里我們可以使用STL中的std::map<void*,pool*>,即建立查找的查詢表，其keys是分配指針(void*),value是
pool*，這里要注意，在從全局的operator new向map中添加數據，因為如果是NULL，會導致遞歸(結束一次插入同時又插入新項)。
這里用map這個STL里的容器，在大多數情況是可以接受的。
除了map，還有一種方案就是耗內存但是速度快些。就在在pool*之前加上所有的allocate(分配)，如果字節是24，考慮到邊界對齊(double\long long),可能需要28或32字節，首先給pool*四個字節，然后返回4或8個字節的(指針)，從你開始分配時；此時全局的delete opeator至少可以刪除這4或8字節指針而不會出現異常，這是如果pool*是null，那么用free調用pool->dealloc()，由free和pool->dealloc（）會有4或8字節的指針到原參p，如果不為空，你就可以決定4字節對齊，代碼就要像下面示例的這樣：
void* operator new(size_t nbytes)
{
if (nbytes == 0)
nbytes = 1; // so all alloc's get a distinct address
void* ans = malloc(nbytes + 4); // overallocate by 4 bytes
*(Pool**)ans = NULL; // use NULL in the global new
return (char*)ans + 4; // don't let users see the Pool*
}
void* operator new(size_t nbytes, Pool& pool)
{
if (nbytes == 0)
nbytes = 1; // so all alloc's get a distinct address
void* ans = pool.alloc(nbytes + 4); // overallocate by 4 bytes
*(Pool**)ans = &pool; // put the Pool* here
return (char*)ans + 4; // don't let users see the Pool*
}
void operator delete(void* p)
{
if (p != NULL) {
p = (char*)p - 4; // back off to the Pool*
Pool* pool = *(Pool**)p;
if (pool == null)
free(p); // note: 4 bytes left of the original p
else
pool->dealloc(p); // note: 4 bytes left of the original p
}
}
上面的代碼并沒有處理new operator內存不足的情況，如果我們不改變全局的new operator和delete operator，上面的問題依然存在。