smart memory pool ：内存池－－智能内存池 新鲜大出炉啦

转，可以，标明出处吧，呵呵。
/************************************************************************
* Smart Memory Pool
* author: kelvin
* date: 2007-11-29
* info: 最近一直想写一个智能内存池，该内存池只有取出操作，当用户不再使用到
该指针，那么指针自动回到内存池中。这个很类似于智能指针的操作，只是
智能指针是当没有引用的时候，自动销毁。
使用者对取出的指针的使用，仅仅通过传递值或者引用来完成。
************************************************************************/

#pragma once

#include <assert.h>
#include <list>
#include <boost/thread/mutex.hpp>

using namespace std;

template <typename T>
class kelvin_SmartMemPool;

template<typename POINTERTYPE>
class kelvin_ptr
{
public:
int *m_pRef;
POINTERTYPE *m_pPtr;
kelvin_SmartMemPool< POINTERTYPE > *m_MemPool;

private:
boost::mutex m_mutexRef;

public:
explicit kelvin_ptr()
:m_pRef(NULL)
,m_pPtr(NULL)
,m_MemPool(NULL)
{
}

// 构造一个智能指针
explicit kelvin_ptr(POINTERTYPE *pPtr, kelvin_SmartMemPool< POINTERTYPE >* MemPool)
:m_MemPool(MemPool)
{
// 确认指针有效
assert(pPtr);

AddRef(NULL);
m_pPtr = pPtr;
}

~kelvin_ptr() { Release(); }

// 重载拷贝构造，增加引用记数
kelvin_ptr(const kelvin_ptr<POINTERTYPE> &obj)
{
AddRef(obj.m_pRef);
m_pPtr = obj.m_pPtr;
m_MemPool = obj.m_MemPool;
}

// 重载赋值操作,使得可以对智能指针之间赋值
const kelvin_ptr<POINTERTYPE>& operator=(kelvin_ptr<POINTERTYPE> &obj)
{
// 首先要减少以前的对象的引用记数，然后在指向新的指针。
Release();

AddRef(obj.m_pRef);
m_pPtr = obj.m_pPtr;
m_MemPool = obj.m_MemPool;

return *this;
}

// 重载*运算符
POINTERTYPE& operator*()
{
assert(m_pPtr);
return *m_pPtr;
}

// 重载->运算符
POINTERTYPE* operator->()
{
assert(m_pPtr);
return m_pPtr;
}

protected:
// 增加引用记数
void AddRef(int *pRef)
{
if (pRef == NULL)
{
m_pRef = new int;
*m_pRef = 0;
}
else
{
m_pRef = pRef;
}

{
boost::mutex::scoped_lock lock(m_mutexRef);
(*m_pRef)++;
}
//InterlockedIncrement((LONG*)m_pRef);
}

// 减少引用记数
void Release()
{
if (m_pRef != NULL)
{
{
boost::mutex::scoped_lock lock(m_mutexRef);
(*m_pRef)--;
}
//InterlockedDecrement((LONG*)m_pRef);

if ( (*m_pRef) == 1)
{
//SmartMemPool<POINTERTYPE>::T pObj = *this;
//m_MemPool.freeMem( (SmartMemPool<POINTERTYPE>::T*)(this) );
m_MemPool->freeMem( *this );

/// 这里由于在放回内存池的时候多了次拷贝构造，引起了记数多1，但是不能继续放在那边去减少记数，
/// 否则，则循环调用了freeMem.所以在这里对该对象引用记数－1
{
boost::mutex::scoped_lock lock(m_mutexRef);
(*m_pRef)--;
}

return;
}

if ( (*m_pRef) == 0)
{
if (m_pPtr != NULL)
{
delete m_pPtr;
m_pPtr = NULL;
}

delete m_pRef;
m_pRef = NULL;
}
}
}
};

template <typename TT>
class kelvin_SmartMemPool
{
public:
typedef kelvin_ptr<TT> T;

public:
explicit kelvin_SmartMemPool()
:m_iMemLength(10)
{
//MemPool(10); /** 这里千万不要这么调用，构造中重复调用构造，实际上是生成了临时对象**/
for (int i = 0; i < m_iMemLength; i++)
{
T* pNode = new T(new TT, this);
assert(pNode);
m_listMem.push_back( pNode );
}
}

explicit kelvin_SmartMemPool(int iLength)
:m_iMemLength(iLength)
{
for (int i = 0; i < m_iMemLength; i++)
{
T* pNode = new T(new TT, this);
assert(pNode);
m_listMem.push_back( pNode );
}
}

virtual ~kelvin_SmartMemPool()
{
for (list< T* >::iterator itr = m_listMem.begin(); itr != m_listMem.end(); /*itr++*/)
{
((*itr))->~T();
//delete (*itr);
//(*itr)->Release();
*itr = NULL;
m_listMem.erase(itr++);
}

m_listMem.clear();

m_iMemLength = 0;
}

T getMem()
{
T *pNode = NULL;

{
boost::mutex::scoped_lock lock(m_mutexLockList);
if (m_listMem.size() > 0)
{
list< T* >::iterator itr = m_listMem.begin();
pNode = (*itr);
m_listMem.erase(itr);

m_iMemLength--;
}
else
{
pNode = new T(new TT, this);
assert(pNode);
//m_iMemLength++; //这里是个bug，iMemLength应该记载还剩的空余内存
}
}

return *pNode;

}

//void freeMem(T* pNode)
//{
// boost::mutex::scoped_lock lock(m_mutexLockList);
// m_listMem.push_back( pNode );
// m_iMemLength++;
//}

void freeMem(T Node)
{
if (Node.m_MemPool == NULL)
{
return ;
}

boost::mutex::scoped_lock lock(m_mutexLockList);
T* pNode = new T();
*pNode = Node;
m_listMem.push_back( pNode );
m_iMemLength++;
}

int getSize()
{
return m_iMemLength;
}

private:
list< T* > m_listMem;
int m_iMemLength;

boost::mutex m_mutexLockList;
};

有兴趣可以跟我留言，共同讨论如何把内存池写的更好，呵呵。