栈--链式存储

基类：

/*
*FileName: Stack.h
*Creater: QianChenglong
*Date: 2011/10/22
*Comments: the abstract base class of stack
*/
#ifndef STACK_H
#define STACK_H

template<typename T>
class Stack
{
public:
Stack() {}
~Stack() {}
virtual bool push(const T& elem) =0;
virtual bool pop(T& elem) =0;
virtual T pop() =0;
virtual bool getTop(T& elem) const=0;
virtual T getTop() const=0;

virtual int length() const=0;
virtual bool isEmpty() const=0;
virtual void clear() =0;
virtual void outPut() const=0;
};
#endif

类定义：

#pragma once
#ifndef LINKEDSTACK_H
#define LINKEDSTACK_H

#include <iostream>
#include "Stack.h"

template<typename T> class LinkedStack;//预引用
template<typename T> std::ostream& operator<<(std::ostream& out,LinkedStack<T>& stack);

template<typename T>
class LinkedStack:public Stack<T>{//链栈类型定义
private:
struct ListNode;
ListNode* top;//栈顶指针
public:
LinkedStack();//进行初始化工作
~LinkedStack();//销毁栈

bool push(const T& elem);//elem进栈
bool pop(T& elem);//出栈，elem返回出栈的元素的值
T pop();//出栈，函数返回出栈元素的值
bool getTop(T& elem) const;//取栈顶，elem返回栈顶值
T getTop() const;//去栈顶，函数返回栈顶值

int length() const;//求栈长
bool isEmpty() const;//判空
void clear();//清栈
void outPut() const;//从栈顶到栈底输出元素

friend std::ostream& operator<< <T> (std::ostream& out,LinkedStack<T>& stack);
};

template<typename T>
struct LinkedStack<T>::ListNode{//链栈节点类型定义
T data;
ListNode* next;

ListNode();
ListNode(const T& _data);
};

#include "LinkedStack.cpp"
#endif

类定义：

#ifndef LINKEDSTACK_CPP
#define LINKEDSTACK_CPP

#include<iostream>
#include"LinkedStack.h"

///////////////////////////////////////////////////////////////////////
template<typename T>
LinkedStack<T>::ListNode::ListNode()
:next(0)
{}

////////////////////////////////////////////////////////////////////////
template<typename T>
LinkedStack<T>::ListNode::ListNode(T const & _data)
:data(_data)
{}

////////////////////////////////////////////////////////////////////////////
template<typename T>
LinkedStack<T>::LinkedStack()//默认构造函数
:top(0)
{}

//////////////////////////////////////////////////////////////////////////
template<typename T>
void LinkedStack<T>::clear(){//清栈
ListNode* work;
while(top){//当栈顶指针不为空时，执行
work=top;//栈顶指针赋给work
top=work->next;//新的栈顶为原来栈顶的下一个节点
delete work;//释放原来栈顶空间
}
}

//////////////////////////////////////////////////////////////////////////////////
template<typename T>
bool LinkedStack<T>::push(const T& elem){//利用头插法实现链栈；
ListNode* newNode=new ListNode(elem);//创建新节点
if(!newNode) return 0;
newNode->next=top;//新节点的next指向原来的栈顶节点
top=newNode;//新节点成为栈顶
return 1;
}

///////////////////////////////////////////////////////////////////////////////
template<typename T>
bool LinkedStack<T>::pop(T& elem){//出栈
if(isEmpty())//若栈空，则失败
return 0;
elem=top->data;
top=top->next;//禅山新栈顶节点
return 1;
}

///////////////////////////////////////////////////////////////////////
template<typename T>
T LinkedStack<T>::pop(){//出栈
if(isEmpty())
return top->data;//若为空，返回头结点内容；
ListNode* work=top;
top=top->next;
return work->data;
}

////////////////////////////////////////////////////////////
template<typename T>
bool LinkedStack<T>::getTop(T& elem) const{//取栈顶
if(isEmpty())
return 0;
elem=top->data;
return 1;
}

////////////////////////////////////////////////////////////
template<typename T>
T LinkedStack<T>::getTop() const{//取栈顶
if(isEmpty())
return top->data;
return top->data;
}

//////////////////////////////////////////////////////////
template<typename T>
int LinkedStack<T>::length() const{//求栈长
ListNode* work=top;
int length=0;
while(work){
++length;
work=work->next;
}
return length;
}

/////////////////////////////////////////////////////////////////////
template<typename T>
bool LinkedStack<T>::isEmpty() const{//判空
return top==0;
}

//////////////////////////////////////////////////////////////////////
template<typename T>
void LinkedStack<T>::outPut() const{//从栈顶到栈底的元素
ListNode* work=top;
while(work){
std::cout<<work->data<<' ';
work=work->next;
}
std::cout<<std::endl;
}

//////////////////////////////////////////////////////////////////////////
template<typename T>//显式的给模板函数指定类型实参
std::ostream& operator<< <T>(std::ostream& out,LinkedStack<T>& stack){//重载<<
typename LinkedStack<T>::ListNode* work=stack.top;
while(work){
out<<work->data<<' ';
work=work->next;
}
out<<std::endl;
return out;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename T>
LinkedStack<T>::~LinkedStack(){//析构函数
clear();
}
#endif

功能测试：

#include<iostream>
#include "LinkedStack.h"

int main()
{
LinkedStack<char> Sa;
char elem;
std::cout<<Sa.length()<<' '<<Sa.isEmpty()<<std::endl;
while(std::cin>>elem)
Sa.push(elem);
Sa.outPut();
std::cout<<Sa.length()<<' '<<Sa.isEmpty()<<std::endl;
Sa.getTop(elem);
std::cout<<elem<<std::endl;
Sa.pop(elem);
std::cout<<Sa;
Sa.clear();
Sa.pop(elem);

return 0;
}