stack.h

VC6.0环境下的多项式计算

#ifndef STACK_H_
#define STACK_H_

#include <iostream>
using namespace std;

template <class T>
class stackList;// 节点

template <class T>
class stackNode
{
public:
friend stackList<T>;
private:
T data;
int type ;//(int : 0  char :1)
stackNode<T> * next;
};


// 链栈模板类
template <class T>
class stackList 
{
public:
// Operations Methods
void pop(T & node );                              // 出栈函数
void pop() ;									  // 重载出栈函数 （方便于 不需要取得节点的值）
void push(const T & NewNode);                     // 入栈函数
void push(const T & NewNode ,const int ) ;        // 重载入栈函数
T getTop() const;                                 // 取得栈顶节点的值
void setType(const int);	                      // 设置栈顶节点的类型
int getType() const;							  // 取得栈顶节点的类型
void clear(void);                                 // 清空该栈
int getLength(void) const;                        // 取得栈的长度
bool empty(void) const;                           // 判断栈是否为空
stackList() ;                                     // 构造函数
~stackList();                                     // 析构函数
private:
	stackNode<T> * m_pbottom;
	stackNode<T> * m_ptop;
	int m_count;
};//////////////////////////////////////////////////////////////////////////
// 实现代码
//////////////////////////////////////////////////////////////////////////

/*
	   构造函数
	   name : stackList
*/
template <class T>
stackList<T>::stackList():m_pbottom(NULL), m_ptop(NULL), m_count(0)
{}

/*
	析构函数
	name : ~stackList
*/
template <class T>
stackList<T>::~stackList()
{
clear();
}

/*
	出栈函数
	name : pop
	return type : void
	function : 将节点出栈
*/
template <class T>
void stackList<T>::pop(T & node)
{
if (m_ptop == NULL) 
   return;
stackNode<T> *pRemove=m_ptop;
m_ptop = m_ptop->next;
if(m_ptop == NULL)
	m_pbottom = NULL ;
node = pRemove->data;
delete pRemove;

m_count--;
}

/*
	出栈函数
	name : pop
	return type : void
	function : 将节点出栈
*/

template<class T>
void stackList<T>::pop()
{
	if(m_ptop == NULL)
		return ;
	stackNode<T> *pRemove = m_ptop ;
	m_ptop = m_ptop->next ;
	if(m_ptop == NULL)
	    m_pbottom = NULL ;
	delete pRemove ;
	m_count-- ;
}

/*
	入栈函数
	name : push
	return type : void 
	function : 将节点入栈
*/
template <class T>
void stackList<T>::push(const T & NewNode)
{
stackNode<T> *p;
p = new stackNode<T>;
p->data = NewNode;
if (m_pbottom == NULL)
{
   p->next = NULL;
   m_pbottom = m_ptop = p;
}
else
{
   p->next = m_ptop;
   m_ptop = p;
}
m_count++;
}


/*
	入栈函数
	name : push
	return type : void 
	function : 将节点入栈
*/
template <class T>
void stackList<T>::push(const T & NewNode, const int type)
{
stackNode<T> *p;
p = new stackNode<T>;
p->data = NewNode;
p->type = type ;
if (m_pbottom == NULL)
{
   p->next = NULL;
   m_pbottom = m_ptop = p;
}
else
{
   p->next = m_ptop;
   m_ptop = p;
}
m_count++;
}


/*
	取得栈顶节点的值
	name : getTop
	return type : T 
	function :取得栈顶节点的值
*/
template <class T>
T stackList<T>::getTop() const
{
	T node ;
if (m_ptop == NULL) 
    return NULL;
node = m_ptop->data;
return node ;
}

/*
	取得栈长
	name : getLength
	return type : int
	function: 取得栈长
*/
template <class T>
int stackList<T>::getLength(void) const
{
return m_count;
}

/*
	判断栈是否为空
	name : empty
	return type : bool
	function : 判断栈是否为空
*/
template <class T>
bool stackList<T>::empty(void) const
{ 
return (m_top == NULL);
}

/*
	清空栈
	name : clear
	return type : clear
	function : 清空栈
*/
template <class T>
void stackList<T>::clear(void)
{

while (m_ptop != NULL)
{
   pop();
}
}

/*
*   设置栈顶节点的类型
*   name : setType()
*/

template < class T >
void stackList<T>::setType(const int type)	
{
	m_ptop->type = type ;
}

/*
*   取得栈顶节点的类型
*	name:getType
*/
template<class T>
int stackList<T>::getType() const
{
	if(m_ptop == NULL)
		return -1 ;
	int type ;
	type = m_ptop->type ;
	return type ;
}

#endif