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

#ifndef CMyStack_h 
#define CMyStack_h 
 
 
#include  
#include  
 
template  
class CMyStack 
{ 
public: 
	CMyStack(); 
	CMyStack( int size ); 
	~CMyStack(); 
 
	bool Init( int size ); 
	void Free(); 
 
	bool Push( T &t ); 
	bool Pop( T &t ); 
 
	void Clear(); 
 
	bool IsEmpty() {return m_top == -1;} 
	bool IsFull() {return m_top + 1 >= m_size;} 
private: 
	T	*m_stack; 
	int m_top; 
	int m_size; 
}; 
 
const int DEFAULT_STACK_SIZE = 4; 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
CMyStack::CMyStack() 
{ 
	m_stack = NULL; 
	m_top = -1; 
	m_size = 0; 
} 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
CMyStack::CMyStack( int size ) 
{ 
	m_stack = NULL; 
	m_top = -1; 
	m_size = 0; 
	Init( size ); 
} 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
CMyStack::~CMyStack() 
{ 
	Free(); 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
bool CMyStack::Init( int size ) 
{ 
	if ( m_stack == NULL ) 
	{ 
		if ( size < DEFAULT_STACK_SIZE ) 
			size = DEFAULT_STACK_SIZE; 
 
		m_stack = (T *)malloc( size * sizeof(T) ); 
		if ( m_stack != NULL ) 
		{ 
			m_size = size; 
			return true; 
		} 
	} 
 
	return false; 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
void CMyStack::Free() 
{ 
	if ( m_stack != NULL ) 
	{ 
		Clear(); 
		free( m_stack ); 
		m_stack = NULL; 
		m_top = 0; 
		m_size = 0; 
	} 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
bool CMyStack::Push( T &t ) 
{ 
	if ( m_top+1 < m_size ) 
	{ 
		++m_top; 
		::new ( &m_stack[m_top] ) T; 
		m_stack[m_top] = t; 
		 
		return true; 
	} 
 
	return false; 
} 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
bool CMyStack::Pop( T &t ) 
{ 
	if ( m_top > -1 ) 
	{ 
		t = m_stack[m_top]; 
		m_stack[m_top].~T(); 
		--m_top; 
		return true; 
	} 
 
	return false; 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
void CMyStack::Clear() 
{ 
	for ( int i = m_top; i >= 0; --i ) 
	{ 
		m_stack[i].~T(); 
	} 
 
	m_top = -1; 
} 
 
 
template  
class CStaticStack 
{ 
public: 
	CStaticStack(); 
	~CStaticStack(); 
 
	bool Push( const T &t ); 
	bool Pop( T &t ); 
 
	void Clear(); 
 
	bool IsEmpty() {return m_top == -1;} 
	bool IsFull() {return m_top + 1 >= n;} 
 
	T *GetStack() { return m_stack; } 
	int GetTop() { return m_top; } 
private: 
	T	m_stack[n]; 
	int m_top; 
}; 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
CStaticStack::CStaticStack() 
{ 
	m_top = -1; 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
CStaticStack::~CStaticStack() 
{ 
	Clear(); 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
bool CStaticStack::Push( const T &t ) 
{ 
	if ( m_top+1 < n ) 
	{ 
		++m_top; 
		::new ( &m_stack[m_top] ) T; 
		m_stack[m_top] = t; 
		 
		return true; 
	} 
 
	return false; 
} 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
bool CStaticStack::Pop( T &t ) 
{ 
	if ( m_top > -1 ) 
	{ 
		t = m_stack[m_top]; 
		m_stack[m_top].~T(); 
		--m_top; 
		return true; 
	} 
 
	return false; 
} 
 
 
/////////////////////////////////////////////////////////////// 
// 
/////////////////////////////////////////////////////////////// 
template  
void CStaticStack::Clear() 
{ 
	for ( int i = m_top; i >= 0; --i ) 
	{ 
		m_stack[i].~T(); 
	} 
 
	m_top = -1; 
} 
#endif