完整的stl allocator代码及其测试

内存池代码如下：

#ifndef POOL_H_INCLUDED_GF
#define POOL_H_INCLUDED_GF

//
// 大块内存分配器
//

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4018) // signed/unsigned mismatch
#pragma warning(disable : 4290) // exception spec ignored
#endif

#include <exception>
#include <list>
#include <algorithm>
#include <iostream>
#include <cassert>

#define TYPE_CAST(DstType, SrcData) reinterpret_cast<DstType>(SrcData)

// 数据块节点,形成链表
struct SBlockHead
{
SBlockHead* poPrev; // prev指针
SBlockHead* poNext; // next指针
size_t nSize; // 块大小
int nFree; // 剩余数量

SBlockHead(SBlockHead* prev, SBlockHead* next, size_t size, int free) :
poPrev(prev), poNext(next), nSize(size), nFree(free)
{
}
~SBlockHead()
{
}
};

class CChunkPool
{
struct SKiller
{
void operator()(char *p)
{
delete [] p;
}
};

enum Pool_Const
{
MEM_INIT_SIZE = 0xfffff,
MEM_MIN_SIZE = 0xf,
BLOCK_SZIE = sizeof(SBlockHead),
};
enum Block_Use
{
BLOCK_USE = 0, BLOCK_UNUSE = 1,
};

public:
// 分配内存，并注册到系统中去
CChunkPool(size_t size = MEM_INIT_SIZE) : m_nSize(size)
{
if((m_nSize - BLOCK_SZIE) < MEM_MIN_SIZE)
{
assert(false);
}

char* poBlock = new char[m_nSize];
if (!poBlock)
{
throw std::bad_alloc();
}

m_listMemPool.push_back(poBlock);
m_poMemBlocks = (SBlockHead*)poBlock;
m_poMemBlocks->poPrev = 0;
m_poMemBlocks->poNext = 0;
m_poMemBlocks->nFree = BLOCK_UNUSE;
m_poMemBlocks->nSize = (m_nSize - BLOCK_SZIE);
}
~CChunkPool()
{
std::for_each(m_listMemPool.begin(), m_listMemPool.end(), SKiller());
}

public:
// 分配size大小的内存，跟具体的对象无关
void* allocate(size_t size)
{
if(size > (m_nSize - BLOCK_SZIE))
{
throw std::bad_alloc();
}

// 如果没有足够的空间，就首先分配空间
SBlockHead* poBlock = m_poMemBlocks;
while (1)
{
while (BLOCK_USE == poBlock->nFree)
{
if(0 == poBlock->poNext)
{
__Buy(poBlock);
}
poBlock = poBlock->poNext;
}

if(poBlock->nSize < size)
{
if (0 == poBlock->poNext)
{
__Buy(poBlock);
}
else
{
poBlock = poBlock->poNext;
}
continue;
}

break;
}

// 剩余的内存不足一个SBlockHead, 就直接全部返回
if(poBlock->nSize - size < 2 * BLOCK_SZIE)
{
poBlock->nFree = BLOCK_USE;
return TYPE_CAST(char*, poBlock) + BLOCK_SZIE;
}
else
{
// 把剩余的内存保存起来
SBlockHead * poLeftBlock = (SBlockHead*)(TYPE_CAST(char*, poBlock) + size + BLOCK_SZIE);
assert(poLeftBlock);

if(poBlock->poNext)
{
poBlock->poNext->poPrev = poLeftBlock;
}

poLeftBlock->poNext = poBlock->poNext;
poBlock->poNext = poLeftBlock;
poLeftBlock->poPrev = poBlock;
poBlock->nFree = BLOCK_USE;
poLeftBlock->nSize = poBlock->nSize - size - BLOCK_SZIE;
poBlock->nSize = size;
poLeftBlock->nFree = BLOCK_UNUSE;
return TYPE_CAST(char*, poBlock) + BLOCK_SZIE;
}
}

// 释放内存，poMem是从allocate函数中分配的
void deallocate(void* poMem, size_t nSize = 0)
{
if(!poMem)
{
return;
}

// 得到原来的SBlockHead*
SBlockHead* poBlock = TYPE_CAST(SBlockHead*, (static_cast<char*>(poMem) - BLOCK_SZIE));

// 既有前节点，又有后节点，下同
if(poBlock->poPrev && poBlock->poNext)
{
if(poBlock->poPrev->nFree && poBlock->poNext->nFree)
{
poBlock->poPrev->nSize += poBlock->nSize + poBlock->poNext->nSize + 2 * BLOCK_SZIE;
poBlock->poPrev->poNext = poBlock->poNext->poNext;
if(poBlock->poNext->poNext)
{
poBlock->poNext->poNext->poPrev = poBlock->poPrev;
}
return;
}
}

if(poBlock->poPrev)
{
if(poBlock->poPrev->nFree)
{
poBlock->poPrev->nSize += (poBlock->nSize + BLOCK_SZIE);
poBlock->poPrev->poNext = poBlock->poNext;
if(poBlock->poNext)
{
poBlock->poNext->poPrev = poBlock->poPrev;
}
poBlock->nFree= BLOCK_UNUSE;
return;
}
}

if(poBlock->poNext)
{
if(poBlock->poNext->nFree)
{
poBlock->nSize += (poBlock->poNext->nSize + BLOCK_SZIE);
poBlock->poNext = poBlock->poNext->poNext;
if(poBlock->poNext)
{
poBlock->poNext->poPrev = poBlock;
}
poBlock->nFree = BLOCK_UNUSE;
return;
}
}

poBlock->nFree = BLOCK_UNUSE;
}

// 显示内存使用情况
void dump()
{
using namespace std;
SBlockHead *b = m_poMemBlocks;
while(1)
{
cout << "Size=" << b->nSize << ", free=" << b->nFree <<
", prev=" << b->poPrev << ", next=" << b->poNext << endl;
if(b->poNext)
{
b = b->poNext;
}
else
{
break;
}
}
}

protected:
// 增长内存一块m_nSize的内存，并加入到poOldBlock后面
void __Buy(SBlockHead* poOldBlock)
{
char* poNewMem = new char[m_nSize];
if (!poNewMem)
{
throw std::bad_alloc();
}
m_listMemPool.push_back(poNewMem);

SBlockHead* poNewBlock = TYPE_CAST(SBlockHead*, poNewMem);
poNewBlock->poPrev = poOldBlock;
poNewBlock->poNext = 0;
poNewBlock->nFree = BLOCK_UNUSE;
poNewBlock->nSize = (m_nSize - BLOCK_SZIE);
poOldBlock->poNext = poNewBlock;
}

private:
size_t m_nSize;
std::list<char *> m_listMemPool;
SBlockHead* m_poMemBlocks;
};

#ifdef _WIN32
#pragma warning(pop)
#endif

#endif

stl allocator 代码如下：

#ifndef __STL_ALLOCATOR_H__
#define __STL_ALLOCATOR_H__

//
// 大块动态allocator，可以用于STL容器的分配器
//

#include "dynamicmempool.h"

// 申明
template <typename T> class CDynamicAllocator;

// 偏特化void
template <> class CDynamicAllocator<void>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;

template <class U>
struct rebind { typedef CDynamicAllocator<U> other; };
};

// Allocator definition
template <typename T>
class CDynamicAllocator
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;

template <class U>
struct rebind
{
typedef CDynamicAllocator<U> other;
};

CDynamicAllocator() {}
template <class U> CDynamicAllocator(const CDynamicAllocator<U>&){}

public:
pointer address(reference x) const { return &x; }
const_pointer address(const_reference x) const { return &x; }

// 分配函数
pointer allocate(size_type size, const_pointer hint = 0)
{
return static_cast<pointer>(m_oMemPool.allocate(size * sizeof(T)));
}

// 释放内存
void deallocate(pointer p, size_type n)
{
m_oMemPool.deallocate(p, n);
}
void deallocate(void* p, size_type n)
{
m_oMemPool.deallocate(p, n);
}

size_type max_size() const throw()
{
return size_t(-1) / sizeof(value_type);
}

void construct(pointer p, const T& val)
{
new(static_cast<void*>(p)) T(val);
}

void construct(pointer p)
{
new(static_cast<void*>(p)) T();
}

void destroy(pointer p) { p->~T(); }

private:
static CChunkPool m_oMemPool;
};

template <class T>
CChunkPool CDynamicAllocator<T>::m_oMemPool;

#endif

测试代码如下：

// test.cpp : 定义控制台应用程序的入口点。.
//

#include "stdafx.h"
#include <iostream>
#include "dynamicallocator.h"
#include <time.h>
#include <vector>
using namespace std;

struct SInfo
{
int nA;
int nB;

SInfo() : nA(0), nB(0)
{
}
SInfo(int i, int j) : nA(i), nB(j)
{

}

~SInfo()
{

}
};

int _tmain(int argc, _TCHAR* argv[])
{
vector<SInfo, CDynamicAllocator<SInfo> > vecInt;

clock_t now = clock();
for (int j = 0; j < 10000; j++)
{
for (int i = 0; i < 0xffff / 4; i++)
{
vecInt.push_back(SInfo(i, 0));
}
vecInt.clear();
}

clock_t end = clock();

int n = end - now;

return 0;
}