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

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*>();