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

实现一个简单的整数计算器，能够进行加、减、乘、除和乘方运算。使用时算式采用后缀输入法，每个操作数、操作符之间都以空白符分隔。乘方运算用“^”表示。每次运算在前次结果基础上进行，若要将前次运行结果清除，可键入“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();
}