栈的应用——一个简单的整数计算器

实现一个简单的整数计算器，能够进行加、减、乘、除和乘方运算。使用时算式采用后缀输入法，每个操作数、操作符之间都以空白符分隔。乘方运算用“^”表示。每次运算在前次结果基础上进行，若要将前次运行结果清除，可键入“c”。当键入“q”时程序结束。

//stack.h

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<cstring>
using namespace std;

enum Boolean {false,true};
const int MaxStackSize=50; //栈的大小，即栈中元素的最大个数

template <class T>
class Stack
{
private:
T stacklist[MaxStackSize]; //数组，用于存放栈的元素
int top; //栈顶位置（数组下标）
public:
Stack(void); //构造函数，初始化栈
void Push(const T& item); //将元素item压入栈
T Pop(void); //将栈顶元素弹出栈
void ClearStack(void); //将栈清空
T peek(void) const; //访问栈顶元素

int StackEmpty(void) const; //测试是否栈空
int StackFull(void) const; //测试是否栈满
};
template<class T>
Stack<T>::Stack(void):top(-1) //构造函数，栈顶初始化为-1
{}

template<class T>
void Stack<T>::Push(const T& item) //将元素item压入栈
{
if(top==MaxStackSize-1)
{
std::cerr<<"Stack overflow!"<<endl;
exit(1);
}
top++;
stacklist[top]=item;
}

template<class T>
T Stack<T>::Pop(void) //将栈顶元素弹出栈
{
T temp;
if(top==-1)
{
std::cerr<<"Attempting to pop an empty stck!"<<endl;
exit(1);
}
temp=stacklist[top];
top--;
return temp;
}

template<class T>
T Stack<T>::peek(void) const //访问栈顶元素
{
if(top==-1)
{
std::cerr<<"Attempting to peek at an empty stack!"<<endl;
exit(1);
}
return stacklist[top];
}

template<class T>
int Stack<T>::StackEmpty(void) const //测试栈是否空
{
return top==-1;
}

template<class T>
int Stack<T>::StackFull(void) const //测试栈是否满
{
return top=MaxStackSize-1;
}

template<class T>
void Stack<T>::ClearStack(void)
{
top=-1;
}

//calculator.h

class Calculator //计算器类
{
private:
Stack <int> S; //操作数栈
void Enter(int num);//将操作数num压入栈
//连续将两个 操作数弹出栈，放在opnd1和opnd2中
Boolean GetTwoOperands(int& opnd1,int& opnd2);
void Compute(char op); //执行由操作符op指定的运算
public:
Calculator(void); //构造函数
void Run(void); //运行计算器程序
void Clear(void); //清空操作数栈
};
void Calculator::Enter(int num)
{
S.Push(num);
}
Boolean Calculator::GetTwoOperands(int& opnd1,int& opnd2)
{
if(S.StackEmpty())
{
cerr<<"Missing operand!"<<endl;
return false;
}
opnd1=S.Pop();
if(S.StackEmpty())
{
cerr<<"Missing operand!"<<endl;
return False;
}
opnd2=S.Pop();
return true;
}

void Calculator::Compute(char op)
{
Boolean result;
int operand1,operand2;
result=GetTwoOperands(operand1,operand2);
if(result==True)
{
switch(op)
{
case '+': S.Push(operand2+operand1);
break;
case '-': S.Push(operand2-operand1);
break;
case '*': S.Push(operand2*operand1);
break;
case '/': if(operand1==0)
{
cerr<<"Divide by 0!"<<endl;
S.ClearStack();
}
else
S.Push(operand2/operand1);
break;
case '^': S.Push(pow(operand2,operand1));
break;
}
cout<<'='<<S.peek()<<' ';
}
else
S.ClearStack();
}
Calculator::Calculator(void)
{}
void Calculator::Run(void)
{
char c[20];
while(cin>>c,*c!='q') //读入表达式，遇'q'结束
switch(*c)
{
case 'c': S.ClearStack(); //遇'c'清空操作数栈
break;
case '-':
if(strlen(c)>1)
Enter(atoi(c));//将字符串转换为整数，压入栈
else
Compute(*c);
break;
case '+':
case '*':
case '/':
case '^':
Compute(*c);
break;
default: //若读入的是操作数，转换为整型后压入栈
Enter(atoi(c));
break;
}
}
void Calculator::Clear(void)
{
S.ClearStack();
}

//主函数

#include"stack.h"
#include"calculator.h"

int main()
{
Calculator CALC;
CALC.Run();
}