利用堆栈求多项式

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

template<typename T>
class stack
{
private:
    T stacklist[50];

    int top;

public:
    stack(void);

    void push(const T&item);

    T pop(void);

    void clearstack(void);

    T peek(void)const;

    bool stackempty(void)const;

    int stackfull(void)const;
};           //"stack.h"

****************************
#include"stack.h"

//实现堆栈stack
template<typename T>
stack<T>::stack(void)
{
 top = -1;
}

template<typename T>
void stack<T>::push(const T&item)
{
    if(top==49)
    {
        cout<<"the stack is full"<<endl;
        exit(1);
    }
    top++;
    stacklist[top]=item;
}

template<typename T>
T stack<T>::pop(void)
{
    int temp;
    if(top==-1)
    {
        cout<<"stack is empty(pop)"<<endl;
        exit(1);
    }
    temp=stacklist[top];
    top--;
    return temp;
}

template<typename T>
T stack<T>::peek(void)const
{
    if(top==-1)
    {
        cout<<"stack is empty(peek)"<<endl;
        exit(1);
    }
    return stacklist[top];
}

template<typename T>
bool stack<T>::stackempty(void)const
{
    return top == -1;
}

template<typename T>
int stack<T>::stackfull(void)const
{
    if(top==49)
        return 1;
    else return 0;
}

template<typename T>
void stack<T>::clearstack(void)
{
    top=-1;
}

//中缀表达式转换成后缀表达式
void changeExp(char *postexp, const char *exp)
{
 int i = 0;
 stack<char> opp;
 while (*exp != '/0')
 {
  switch(*exp)
  {
  case '(':
   opp.push(*exp);
   exp++;
   break;
  case ')':
   while ((!opp.stackempty()) && (opp.peek() != '('))
   {
    postexp[i++] = opp.pop();
   }
   opp.pop();
   exp++;
   break;
  case '+':
  case '-':
   while ((!opp.stackempty()) && (opp.peek()!='('))
   {
    postexp[i++] = opp.pop();
   }
   opp.push(*exp);
   exp++;
      break;
  case '*':
  case '/':
   if (!opp.stackempty()){
    while (opp.peek()=='*' || opp.peek()=='/')
    {
     postexp[i++] = opp.pop();
    }
   }
   opp.push(*exp); 
   exp++;
      break;
  case ' ':
   exp++;
   break;
  default:
   while ((*exp>='0')&&(*exp<='9'))
   {
    postexp[i++] = *exp;
    exp++;
   }
   postexp[i++] = '#';
      break;
  }
 }
 while (!opp.stackempty())
 {
  postexp[i++] = opp.pop();
 }
 postexp[i] = '/0';
}

//计算表达式值
class Calculate
{
private:
    stack<float> s;//存放操作数的堆栈
   
    void enter(float operand);//将一个float型操作数压入堆栈

    //从栈顶取两个操作数，若栈中不足两个元素，则输出错误信息并异常 终止程序
    void getTwoOperands(float&operand1,float&operand2);

    //调用gettwooperands从栈顶取两个操作数x和y执行运算x<op>y  将运算结果压入栈
    void compute(char op);

    //清空操作数栈
    void clear(void);

public:
    //建立一个空计算器栈
    Calculate(void){};

    //计算表达式值
    void run(char *np);
};

void Calculate::enter(float operand)
{
        s.push(operand);
}
void Calculate::getTwoOperands(float&operand1,float&operand2)
{
    if(!s.stackempty())
    {
        operand1=s.pop();
    }
    if(!s.stackempty())
    {
        operand2=s.pop();
    }
    else
    {
  cout<<"the stack is empty"<<endl;
  exit(1);
    }
}
void Calculate::compute(char op)
{
    float z;
    float operand1;
    float operand2;
    getTwoOperands(operand1,operand2);
    switch(op)
    {
    case'+':
  z=operand1+operand2;
  break;
    case'-':
  z=operand2-operand1;
  break;
    case'*':
  z=operand1*operand2;
  break;
    case'/':
  if(operand2==0)
        {
   cout<<"can not divide 0"<<endl;
   exit(1);
  }
        else
  {
   z=operand2/operand1;
  }
        break;
    }
    s.push(z);
}
void Calculate::clear()
{
    s.clearstack();
}
void Calculate::run(char *np)
{
 float operand;
    while(*np != '/0')
    {
        switch(*np)
        {
   case '+':
    compute(*np);
    break;
   case '-':
    compute(*np);
    break;
   case '*':
    compute(*np);
    break;
   case '/':
    compute(*np);
    break;
   default:
    operand = 0;
    while (*np>='0' && *np<='9')
    { 
     operand = 10*operand + *np - '0';
     np++;
    }
    enter(operand);
    break;
        }
  np++;
    }
    cout<<"rusult :"<<s.pop()<<endl;
    clear();
}

int main()
{
 char *op = new char[50];
 char *np = new char[50];
    cout << "请输入数据 :";
 cin >> op;
 changeExp(np, op);
 cout << np << endl;
    Calculate c;
    c.run(np);
 delete []op;//释放内存
 op = NULL;
 delete []np;
 np = NULL;
    return 0;
}