www.pudn.com > GameEngine_src.rar > CQueue.h

#ifndef CQueue_h 
#define CQueue_h 
#include  
#include  
 
///////////////////////////////////////////////////////////////////// 
//队列类模板 
//最后修改:2007-10-23 
///////////////////////////////////////////////////////////////////// 
template 
class CQueue 
{ 
	private: 
		enum STATE { FULL, EMPTY, NONE, }; 
 
	public: 
		CQueue(); 
		CQueue( int size ); 
		~CQueue(); 
 
		bool Init( int size ); 
		void Free(); 
 
		bool Enqueue( const T &t ); 
		bool Dequeue( T &t ); 
 
		void Clear(); 
 
		bool IsFull() {return m_state == FULL; } 
		bool IsEmpty(){return m_state == EMPTY;} 
 
	private: 
		T	*m_queue; 
		int m_front; 
		int m_rear; 
		int m_size; 
		STATE m_state; 
}; 
 
const DEFAULT_CQ_SIZE = 4; 
 
//////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template 
CQueue::CQueue() 
{ 
	m_queue = NULL; 
	m_front = 0; 
	m_rear  = 0; 
	m_size  = 0; 
	m_state = EMPTY; 
} 
 
template 
CQueue::CQueue( int size ) 
{ 
	Init( size ); 
} 
 
template 
CQueue::~CQueue() 
{ 
	Free(); 
} 
 
//////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template 
bool CQueue::Init( int size ) 
{ 
	m_queue = NULL; 
	m_front = 0; 
	m_rear  = 0; 
	m_size  = 0; 
	m_state = EMPTY; 
	 
	if (size < DEFAULT_CQ_SIZE ) size = DEFAULT_CQ_SIZE; 
 
	m_queue = (T *)malloc( size * sizeof(T) ); 
	if ( m_queue == NULL ) 
		return false; 
 
	m_size = size; 
	return true; 
} 
 
//////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template 
void CQueue::Free() 
{ 
	Clear(); 
 
	if ( m_queue != NULL ) 
	{ 
		 
		free( m_queue ); 
		m_queue = NULL; 
		m_size  = 0; 
		m_state = EMPTY; 
	} 
} 
 
//////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template 
bool CQueue::Enqueue( const T &t ) 
{ 
	if ( m_state != FULL ) 
	{ 
		::new (&m_queue[m_front]) T; 
		m_queue[m_front] = t; 
 
		int i = (m_front+1) % m_size; 
		m_state = NONE; 
		m_front = i; 
 
		if ( i == m_rear ) 
			m_state = FULL; 
		return true; 
	} 
	return false; 
} 
 
//////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template 
bool CQueue::Dequeue( T &t ) 
{ 
	if ( m_state != EMPTY ) 
	{ 
		t = m_queue[m_rear]; 
		m_queue[m_rear].~T(); 
 
		int i = (m_rear+1) % m_size; 
		m_state = NONE; 
		m_rear = i; 
 
		if ( i == m_front ) 
			m_state = EMPTY;	 
		return true; 
	} 
 
	return false; 
} 
 
//////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template 
void CQueue::Clear() 
{ 
	T temp; 
	while ( Dequeue(temp) ); 
} 
 
#endif