stackpool.h

一个双向栈的C++实现

#pragma once

#include <list>
#include "Synchronize.h"

template <class T>
class CStackPool
{
public:
	typedef T* (*CrNodeFunc)(void* param);
public:
	CStackPool(void);
	~CStackPool(void);

private:
	CLock m_lock;
	list<T*> m_list;
	list<T*> m_create_list;
	void* m_create_param;
	CrNodeFunc m_func;

	T* CreateT(void);
public:
	void Init(int init_size, CrNodeFunc func = NULL, void* param = NULL);
	T& Pop(void);
	void Push(T* data);
};

template <class T>
CStackPool<T>::CStackPool(void)
{
	m_create_param = NULL;
	m_func = NULL;
}

template <class T>
CStackPool<T>::~CStackPool(void)
{
	m_lock.Lock();
	for(list<T*>::iterator i = m_create_list.begin(); i != m_create_list.end(); ++i)
	{
		delete *i;
	}
	m_lock.UnLock();
}

template <class T>
inline T* CStackPool<T>:: CreateT(void)
{
	if(m_func != NULL)
		return m_func(m_create_param);
	else
		return new T;
}

template <class T>
void CStackPool<T>::Init(int init_size, CrNodeFunc func, void* param)
{
	m_func = func;
	m_create_param = param;
	T* t;
	for(int i = 0; i < init_size; ++i)
	{
		t = CreateT();
		m_create_list.push_back(t);
		m_list.push_back(t);
	}
}

template <class T>
T& CStackPool<T>::Pop(void)
{
	T* ret;
	m_lock.Lock();
	if(m_list.empty())
	{
		ret = CreateT();
		m_create_list.push_back(ret);
	}
	else
	{
		ret = *m_list.begin();
		m_list.pop_front();
	}
	m_lock.UnLock();
	return *ret;
}

template <class T>
void CStackPool<T>::Push(T* data)
{
	m_lock.Lock();
	m_list.push_front(data);
	m_lock.UnLock();
}