內(nèi)存分配(器)返回的是一塊沒有初始化的內(nèi)存，不返回對象；內(nèi)存分配(器)也不支持設(shè)置成虛指針，因為內(nèi)存分配是在構(gòu)造執(zhí)行后；
1 void* raw = allocate(sizeof(Foo)); // line 1
2 Foo* p = new(raw) Foo(); // line 2
allocate就是一個簡單的內(nèi)存分配(器)，上面的代碼使用了placement new來構(gòu)造對象。
下面一步就是做一個對象的內(nèi)存分配(器)-------------內(nèi)存池(類)
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個內(nèi)存池而不是共享一塊大內(nèi)存，可以從內(nèi)存池中分配而不用釋放，一次釋放整個內(nèi)存池；也可以其中一部分做共享內(nèi)存而不用系統(tǒng)的共享內(nèi)存，從另一個角度來看，很多系統(tǒng)支持alloca()從stack中分配內(nèi)存塊，當(dāng)然這些內(nèi)存塊也會自動離開在函數(shù)返回時，無須delete；當(dāng)然也可以使用alloca()為(內(nèi)存)池分配一個大內(nèi)存塊，而無須調(diào)用delete，在這里析構(gòu)函數(shù)僅僅只是（deallocates）釋放分配的內(nèi)存。
下一步就是就是改變分配對象的語法：與其使用new(pool.alloc(sizeof(Foo)))
Foo() 倒不如new(pool)
Foo()，為此我們需要實現(xiàn)下面的函數(shù)：
inline void* operator new(size_t nbytes, Pool& pool)
{
return pool.alloc(nbytes);
}
現(xiàn)在看看這個new(pool)Foo(),它會調(diào)用operator new，通過sizeof(Foo)和pool兩個參量，下面看看如何析構(gòu)對象和釋放內(nèi)存，根據(jù)placement new的析構(gòu)方法，代碼如下：
void sample(Pool& pool)
{
Foo* p = new(pool) Foo();
p->~Foo(); // explicitly call dtor
pool.dealloc(p); // explicitly release the memory
}
但這樣做，會有下面幾個問題產(chǎn)生：
問題一：防止內(nèi)存泄露，在Foo* p = new Foo()，編譯器會產(chǎn)生類似下面的代碼來應(yīng)對構(gòu)造中的異常
// 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(去分配)內(nèi)存時如發(fā)生異常，具體的說就是new的參數(shù)(調(diào)用placement(布局) new)時出現(xiàn)異常，此時編譯器不知所措，默認(rèn)就什么都不做。
// 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的工作，當(dāng)編譯器看到
new(pool) Foo()，它要查找與之想匹配的delete operator，如果找到了，就相當(dāng)于上面顯示
的包含try的代碼可以正確執(zhí)行，所以要寫個delete operator，像下面的代碼所示（即使第二參數(shù)和operator new(size_t, Pool&)中的第二個參數(shù)不同，也沒有關(guān)系，編譯器也
不會有什么抱怨，此時它會繞過這個try塊）
void operator delete(void* p, Pool& pool)
{
pool.dealloc(p);
}
注意：這個operator delete不必一定是inline的，可以是，也可以不是。
destruction（析構(gòu)）/deallocation(去分配)是兩個不同的概念，可現(xiàn)實中經(jīng)常混淆這兩個；另外要記住內(nèi)存池里的內(nèi)存和哪個對象匹配，一般我們通過Foo *和
pool* 這兩個指針來定位；對于這兩個方面可能出現(xiàn)的問題，可以用下面的方案來解決。
這個方案就是使每次分配(對象)都關(guān)聯(lián)一個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調(diào)用free，可以在全局的new operator中使用malloc(),像下面的代碼所示(此短代碼沒有throw std::bad_alloc()new_handler)
下面的工作就是用pool*關(guān)聯(lián)每次 allocation(分配)，這里我們可以使用STL中的std::map<void*,pool*>,即建立查找的查詢表，其keys是分配指針(void*),value是
pool*，這里要注意，在從全局的operator new向map中添加數(shù)據(jù)，因為如果是NULL，會導(dǎo)致遞歸(結(jié)束一次插入同時又插入新項)。
這里用map這個STL里的容器，在大多數(shù)情況是可以接受的。
除了map，還有一種方案就是耗內(nèi)存但是速度快些。就在在pool*之前加上所有的allocate(分配)，如果字節(jié)是24，考慮到邊界對齊(double\long long),可能需要28或32字節(jié)，首先給pool*四個字節(jié)，然后返回4或8個字節(jié)的(指針)，從你開始分配時；此時全局的delete opeator至少可以刪除這4或8字節(jié)指針而不會出現(xiàn)異常，這是如果pool*是null，那么用free調(diào)用pool->dealloc()，由free和pool->dealloc（）會有4或8字節(jié)的指針到原參p，如果不為空，你就可以決定4字節(jié)對齊，代碼就要像下面示例的這樣：
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內(nèi)存不足的情況，如果我們不改變?nèi)值膎ew operator和delete operator，上面的問題依然存在。