栈之后缀计算器

#include <iostream.h>
#include <stdlib.h>

const int MaxStackSize = 50;
typedef double DataType;

class Stack
{
 private:
  DataType stacklist[MaxStackSize];
  int top;

 public:
  Stack(void);

  void Push(const DataType& item);
  DataType Pop(void);
  void ClearStack(void);

  DataType Peek(void) const;

  int StackEmpty(void) const;
  int StackFull(void) const;
};

Stack::Stack()
{
 top = -1;
}

void Stack::Push(const DataType& item)
{
 if (top == MaxStackSize - 1)
 {
  cerr << "Stack overflow" << endl;
  exit(1);
 }

 stacklist[++top] = item;
}

DataType Stack::Pop()
{
 DataType temp;

 if (top == -1)
 {
  cerr << "Attempt to pop an empty stack" << endl;
  exit(1);
 }
 
 temp = stacklist[top--];

 return temp;
}

DataType Stack::Peek(void) const
{
 DataType temp;

 if (top == -1)
 {
  cerr << "Attempt to pop an empty stack" << endl;
  exit(1);
 }
 
 temp = stacklist[top];

 return temp;
}

int Stack::StackEmpty() const
{
 return top == -1;
}

int Stack::StackFull() const
{
 return top == MaxStackSize - 1;
}

void Stack::ClearStack()
{
 top = -1;
}

class Calculator
{
 private:
  Stack s;

  void Enter(double num);
  bool GetTwoOperands(double& opnd1, double& opnd2);
  void Compute(char op);
 public:
  //Calculator(void);
  void Run(void);
  void Clear(void);
};

void Calculator::Enter(double num)
{
 s.Push(num);
}

bool Calculator::GetTwoOperands(double& opnd1, double& 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)
{
 bool result;
 double operand1,operand2;

 result = GetTwoOperands(operand1,operand2);

 if (result)
 {
  switch(op)
  {
   case '+':
    s.Push(operand2 + operand1);
    break;
   case '-':
    s.Push(operand2 - operand1);
    break;
   case '*':
    s.Push(operand2 * operand1);
    break;
   case '/':
    s.Push(operand2 / operand1);
    break;
  }
 }
 else
 {
  s.ClearStack();
 }
}

void Calculator::Run()
{
 char c;
 double newoperand;

 while (cin >> c, c != '=')
 {
  switch(c)
  {
   case '+':
   case '-':
   case '*':
   case '/':
    Compute(c);
    break;
   default:
    cin.putback(c);
    cin >> newoperand;
    Enter(newoperand);
    break;
  }
 }

 if (!s.StackEmpty())
 {
  cout << s.Peek() << endl;
 }
}

void Calculator::Clear()
{
 s.ClearStack();
}

void main()
{
 Calculator calc;
 
 calc.Run();
}