对象内存池实现

///
/// Copyright (c) xseekerj 2014,All Rights Reserved.
///

#ifndef _OBJECT_POOL_H_
#define _OBJECT_POOL_H_
#ifndef _POLITE_SZ_ALIGN
#define _POLITE_SZ_ALIGN
#define sz_align(d,a) (((d) + (a - 1)) & ~(a - 1))
#endif
template<typename _Ty, size_t _ElemCount = 1024>
class object_pool
{
typedef struct free_link_node
{
free_link_node* next;
} *free_link;

typedef struct chunk_link_node
{
char             data[sz_align(sizeof(_Ty), sizeof(void*)) * _ElemCount];
chunk_link_node* next;
} *chunk_link;

object_pool(const object_pool&);
void operator= (const object_pool&);

public:
object_pool(void) : _Myhead(nullptr), _Mychunk(nullptr), _Mycount(0)
{
this->_Enlarge();
}

~object_pool(void)
{
this->purge();
}

void cleanup(void)
{
if(this->_Mychunk = nullptr) {
return;
}
free_link_node* prev = nullptr;
chunk_link_node* chunk = this->_Mychunk;
for (; chunk != nullptr; chunk = chunk->next)
{
char* begin     = chunk->data;
char* rbegin    = begin + (_ElemCount - 1) * sz_align(sizeof(_Ty), sizeof(void*));
if(prev != nullptr)
prev->next = reinterpret_cast<free_link>(begin);
for (char* ptr = begin; ptr < rbegin; ptr += sz_align(sizeof(_Ty), sizeof(void*)) )
{
reinterpret_cast<free_link_node*>(ptr)->next = reinterpret_cast<free_link_node*>(ptr + sz_align(sizeof(_Ty), sizeof(void*)));
}
prev = reinterpret_cast <free_link_node*>(rbegin);
}
this->_Myhead = reinterpret_cast<free_link_node*>(this->_Mychunk->data);
this->_Mycount = 0;
}

void purge(void)
{
chunk_link_node* ptr = this->_Mychunk;
while (ptr != nullptr)
{
chunk_link_node* deleting = ptr;
ptr = ptr->next;
free(deleting);
}
_Myhead = nullptr;
_Mychunk = nullptr;
_Mycount = 0;
}

size_t count(void) const
{
return _Mycount;
}

// if the type is not pod, you may be use placement new to call the constructor,
// for example: _Ty* obj = new(pool.get()) _Ty(arg1,arg2,...);
void* get(void)
{
if (nullptr == this->_Myhead)
{
this->_Enlarge();
}
free_link_node* ptr = this->_Myhead;
this->_Myhead = ptr->next;
++_Mycount;
return reinterpret_cast<void*>(ptr);
}
void release(void* _Ptr)
{
( (_Ty*)_Ptr)->~_Ty(); // call the destructor
#ifdef _DEBUG
::memset(_Ptr, 0x00, sizeof(_Ty));
#endif
free_link_node* ptr = reinterpret_cast<free_link_node*>(_Ptr);
ptr->next = this->_Myhead;
this->_Myhead = ptr;
--_Mycount;
}

private:
void _Enlarge(void)
{
static_assert(_ElemCount > 0, "Invalid Element Count");

chunk_link new_chunk  = (chunk_link)malloc(sizeof(chunk_link_node));
#ifdef _DEBUG
::memset(new_chunk, 0x00, sizeof(chunk_link_node));
#endif
new_chunk->next = this->_Mychunk;
this->_Mychunk  = new_chunk;

char* begin     = this->_Mychunk->data;
char* rbegin    = begin + (_ElemCount - 1) * sz_align(sizeof(_Ty), sizeof(void*));

for (char* ptr = begin; ptr < rbegin; ptr += sz_align(sizeof(_Ty), sizeof(void*)))
{
reinterpret_cast<free_link_node*>(ptr)->next = reinterpret_cast<free_link_node*>(ptr + sz_align(sizeof(_Ty), sizeof(void*)));
}

reinterpret_cast <free_link_node*>(rbegin)->next = nullptr;
this->_Myhead = reinterpret_cast<free_link_node*>(begin);
}

private:
free_link     _Myhead;  // link to free head
chunk_link    _Mychunk; // chunk link
size_t        _Mycount; // allocated count
};

#endif