pool_allocator轻量模板内存池

只能一次申请一个对象，没有线程锁。

template <typename T, size_t PAGE>
class pool_allocator
{
public:
	typedef pool_allocator    this_type;
	typedef T                 value_type;
	typedef value_type*       pointer;
	typedef const value_type* const_pointer;
	typedef value_type&       reference;
	typedef const value_type& const_reference;
	typedef std::size_t       size_type;
	typedef std::ptrdiff_t    difference_type;

	const static size_t PAGE_SIZE = PAGE;
private:
	struct node{
		node* next;
		//byte_t value[sizeof(value_type)];
		value_type value;
	};
	node* entry;
	static std::vector<void*> poolbuf;
public:
	pool_allocator() : entry()
	{
	}

	pool_allocator(const this_type&) : entry()
	{
	}

	~pool_allocator()
	{
		this->dispose();
	}

	this_type& operator=(const this_type&)
	{
		return *this;
	}

	bool operator==(const this_type&)
	{
		return true;
	}

	bool operator!=(const this_type&)
	{
		return false;
	}

	pointer allocate(size_type size = 1, const_pointer = 0)
	{
		assert(size == 1);
		if(!entry){
			node* buf = allocate_buffer();
			entry = buf;
		}
		node* n = entry;
		entry = entry->next;
		return this->address(n);
	}

	pointer allocate(size_type n, size_type alignment, const_pointer = 0)
	{
		assert(false);
		return null;
	}

	void deallocate(pointer p, size_type = 0)
	{
		//node * n = reinterpret_cast<node*>(p);
		node * n = reinterpret_cast<node*>(reinterpret_cast<byte_t*>(p) - sizeof(node*));
        n->next = entry;
		entry = n;
	}

	pointer reallocate(pointer ptr, size_type n)
	{
		assert(false);
		return null;
	}

	void dispose()
    {
        for(size_type i = 0; i < poolbuf.size(); ++i)
        {
			deallocate_buffer(poolbuf[i]);
		}
		poolbuf.clear();
		entry = null;
	}

	size_type max_size()const
	{
		return static_cast<size_type>(-1)/sizeof(T);
	}

	size_type size()const
	{
		return poolbuf.size() * PAGE_SIZE;
	}

	size_type free_size()const
    {
		size_type n = 0;
		node* p = entry;
        while(p){
            ++n;
            p = p->next;
        }
        return n;
	}

	void construct(pointer p, const value_type& x)
	{
		//new(p) value_type(x);
	}

	void construct(pointer p)
	{
		//new (p) value_type();
	}

	void destroy(pointer p)
	{
		//p->~T();
	}
private:
	node* allocate_buffer()
	{
		node* buf = new node[PAGE_SIZE];
		//node* buf = static_cast<node*>(malloc(PAGE_SIZE * sizeof(node)));

		for(size_type i=0; i<PAGE_SIZE; ++i){
			buf[i].next = buf + i + 1;
		}
		buf[PAGE_SIZE - 1].next = null;
		poolbuf.push_back(buf);
		return buf;
	}

	void deallocate_buffer(void* &buf)
	{
		node* p = static_cast<node*>(buf);
		delete []p;
		//free(buf);
		buf = null;
	}

	pointer address(node* n)
	{
		//return reinterpret_cast<pointer>(n->value);
		return &n->value;
	}
};

template<typename T, size_t P>
std::vector<void*> pool_allocator<T, P>::poolbuf = std::vector<void*>();