#include<iostream>
using namespace std;
#define StackSize 100
template <class T>
class SqStack
{
private:
    T str[StackSize];
    int top;
public:
    void InitStack();
    int StackLength();
    int IsEmpty();
    void Push (T m);
    void Pop(T e);
    T GetTop();
};
//初始化
template <class T>
void SqStack<T>::InitStack()
{

    top = -1;
 
}
//求栈的长度
template <class T>
int SqStack<T>::StackLength()
{
 return(top+1);
}
//判断是否为空栈
template <class T>
int SqStack<T>::IsEmpty()
{
    if(top=-1)
        return 1;
}
 //进栈
template <class T>
void SqStack<T>::Push (T m)
{
  if(top!=StackSize-1)
  {
   top++;
   str[top]=m;
  }
}
 
//退栈
template <class T>
void SqStack<T>::Pop(T e)
{
 if(top!=-1)
   e=str[top];
   top--;
}
 //取栈顶元素
template <class T>
T SqStack<T>::GetTop()
{
  return str[top];
}
//判断是运算符，数字，还是其他
int isOpMember (char ch)
{
    if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'||ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9')
    return 0;
    else if (ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='\0')
    return 1;
    else
    return -1;
}
//各种运算符在运算符优先级矩阵对应的下标
int order (char m)
{
    switch (m)
    {
        case '+':return 0;
        case '-':return 1;
        case '*':return 2;
        case '/':return 3;
        case '(':return 4;
        case ')':return 5;
        case '\0':return 6;
        default :return 7;
    }
}
//判断两运算符运算优先级
int precede (char op1,char op2)
{
    int inCmpOut[7][7]={
    {1,1,-1,-1,-1,1,1},
    {1,1,-1,-1,-1,1,1},
    {1,1,1,1,-1,1,1},
    {1,1,1,1,-1,1,1},
    {-1,-1,-1,-1,-1,0,0},
    {1,1,1,1,2,1,1},
    {-1,-1,-1,-1,-1,2,0}
    };
    int i,j;
    i=order (op1);
    j=order (op2);
    return inCmpOut [i][j];
}
//把中缀表达式转化为后缀表达式
void transform ( char * midS,char * suffixS)
{
    int i=0;
    int j=0;
    char ch = midS[0];
    SqStack<char>s;
    s.InitStack();
    char op;
    s.Push ('\0');
    while (!s.IsEmpty())
    {
        if(!isOpMember(ch))
        {
            if(i>0 && isOpMember( suffixS[i-1]=1))
            suffixS[i++]=' ';
            suffixS[i++]=ch;
        }
        else
        {
            if( i>0 && suffixS[i-1] != ' ')
            suffixS[i++]=' ';
            switch ( ch )
            {
                case '(':s.Push(ch);break;
                case ')':s.Pop(op);
                while(op!='(')
                {
                    suffixS[i++]=op;
                    suffixS[i++]=' ';
                    s.Pop(op);
                }
                --i;
                break;
                default:
                while(op=s.GetTop())
                {
                    if(precede(op,ch)==1||precede(op,ch)==0)
                    {
                        suffixS[i++]=op;
                        suffixS[i++]=' ';
                    }
                    else
                    break;
                    s.Pop(op);
                }
                if(ch!='\0')
                s.Push(ch);
                break;
            }
        }
        if(ch!='\0')
        ch=midS[++j];
    }
    suffixS[i]='\0';
}
//指定运算符的运算
double caculate ( double a, char ch , double b)
{
    switch (ch)
    {
        case '+':return a+b;
        case '-':return a-b;
        case '*':return a*b;
        case '/':return a/b;
        default: return -1;
    }
}
//后缀表达式的计算
double evaluation (char * suffixS)
{
    int i=0;
    char ch=suffixS[i];
    double x;
    SqStack<double>s;
    s.InitStack();
    double a,b;
    while (ch!='\0')
    {
        if(isOpMember(ch)==0)
        {
            x=0;
            while (isOpMember(ch)==0)
            {
                x=10*x+(ch-'0');
                ch=suffixS[++i];
            }
            s.Push(x);
        }
        else if(isOpMember(ch)==1)
        {
            s.Pop(b);
            s.Pop(a);
            s.Push(caculate(a,ch,b));
        }
        ch=suffixS[++i];
    }
s.Pop(x);
return x;
}
            
   

int main()
{
    char chm[100];
    char chn[100];
    cin>>chm;
    transform ( chm,chn);
    cout<<evaluation (chn)<<endl;
}

先加上逐行的注释，再来问

/*表达式求值(范围为int类型,输入负数要用(0-正数)表示)   */
  typedef   int   SElemType;   /*   栈元素类型为整型   */
  #include <string.h>
  #include <ctype.h>
  #include <malloc.h>    /*   malloc()等   */
  #include <limits.h>    /*   INT_MAX等   */
  #include <stdio.h>     /*   EOF(=^Z或F6),NULL   */
  #include <stdlib.h>    /*   atoi()   */
  #include <io.h>        /*   eof()   */
  #include <math.h>      /*   floor(),ceil(),abs()   */
  #include <process.h>   /*   exit()   */
  /*   函数结果状态代码   */
  #define   TRUE   1
  #define   FALSE   0
  #define   OK   1
  #define   ERROR   0
  #define   INFEASIBLE   -1
  typedef   int   Status;   /*   Status是函数的类型,其值是函数结果状态代码，如OK等   */
  typedef   int   Boolean;   /*   Boolean是布尔类型,其值是TRUE或FALSE   */

 
  #define   STACK_INIT_SIZE   10   /*   存储空间初始分配量   */
  #define   STACKINCREMENT   2   /*   存储空间分配增量   */
  typedef   struct   SqStack
  {
      SElemType   *base;   /*   在栈构造之前和销毁之后，base的值为NULL   */
      SElemType   *top;   /*   栈顶指针   */
      int   stacksize;   /*   当前已分配的存储空间，以元素为单位   */
  }SqStack;   /*   顺序栈   */ 


  /*   顺序栈的基本操作（9个）   */
  Status   InitStack(SqStack   *S)
  {   /*   构造一个空栈S   */
      (*S).base=(SElemType   *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
      if(!(*S).base)
          exit(OVERFLOW);   /*   存储分配失败   */
      (*S).top=(*S).base;
      (*S).stacksize=STACK_INIT_SIZE;
      return   OK;
  } 

  Status   DestroyStack(SqStack   *S)
  {   /*   销毁栈S，S不再存在   */
      free((*S).base);
      (*S).base=NULL;
      (*S).top=NULL;
      (*S).stacksize=0;
      return   OK;
  } 

  Status   ClearStack(SqStack   *S)
  {   /*   把S置为空栈   */
      (*S).top=(*S).base;
      return   OK;
  } 

  Status   StackEmpty(SqStack   S)
  {   /*   若栈S为空栈，则返回TRUE，否则返回FALSE   */
      if(S.top==S.base)
          return   TRUE;
      else
          return   FALSE;
  } 

  int   StackLength(SqStack   S)
  {   /*   返回S的元素个数，即栈的长度   */
      return   S.top-S.base;
  } 

  Status   GetTop(SqStack   S,SElemType   *e)
  {   /*   若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR   */
      if(S.top> S.base)
      {
          *e=*(S.top-1);
          return   OK;
      }
      else
          return   ERROR;
  } 

  Status   Push(SqStack   *S,SElemType   e)
  {   /*   插入元素e为新的栈顶元素   */
      if((*S).top-(*S).base>=(*S).stacksize)   /*   栈满，追加存储空间   */
      {
          (*S).base=(SElemType   *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));
          if(!(*S).base)
              exit(OVERFLOW);   /*   存储分配失败   */
          (*S).top=(*S).base+(*S).stacksize;
          (*S).stacksize+=STACKINCREMENT;
      }
      *((*S).top)++=e;
      return   OK;
  } 

  Status   Pop(SqStack   *S,SElemType   *e)
  {   /*   若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR   */
      if((*S).top==(*S).base)
          return   ERROR;
      *e=*--(*S).top;
      return   OK;
  } 

  Status   StackTraverse(SqStack   S,Status(*visit)(SElemType))
  {   /*   从栈底到栈顶依次对栈中每个元素调用函数visit()。   */
      /*   一旦visit()失败，则操作失败   */
      while(S.top> S.base)
          visit(*S.base++);
      printf( "\n ");
      return   OK;
  }

  SElemType   Precede(SElemType   t1,SElemType   t2)  
  {   /*   判断两符号的优先关系   */
      SElemType   f;
      switch(t2)
      {
          case   '+':
          case   '-':if(t1=='('||t1=='=')
                                f= '<';
                            else
                                f='>';
                            break;
          case   '*':
          case   '/':if(t1=='*'||t1=='/'||t1==')')
                                f= '>';
                            else
                                f='<';
                            break;
          case   '(':if(t1==')')
                            {
                                printf("ERROR1\n");
                                exit(ERROR);
                            }
                            else
                                f= '<';
                            break;
          case   ')':switch(t1)
                            {
                                case   '(':f='=';
                                                  break;
                                case   '=':printf("ERROR2\n");
                                                  exit(ERROR);
                                default:   f='>';
                            }
                            break;
          case   '=':switch(t1)
                            {
                                case   '=':f='=';
                                                  break;
                                case   '(':printf("ERROR2\n");
                                                  exit(ERROR);
                                default:   f='>';
                            }
      }
      return   f;
  } 

  Status   In(SElemType   c)  
  {   /*   判断c是否为运算符   */
      switch(c)
      {
          case '+':
          case '-':
          case '*':
          case '/':
          case '(':
          case ')':
          case '=':return   TRUE;  
          default:return   FALSE;
      }
  } 

  SElemType   Operate(SElemType a,SElemType theta,SElemType b)  
  {
      SElemType c;
      switch(theta)
      {
          case '+':c=a+b;
                          break;
          case '-':c=a-b;
                          break;
          case '*':c=a*b;
                          break;
          case '/':c=a/b;
      }
      return   c;
  } 

  SElemType   EvaluateExpression()  
  {   /*   算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈   */
      SqStack   OPTR,OPND;
      SElemType   a,b,d,x,theta;
      char   c;   /*   存放由键盘接收的字符串   */
      char   z[6];   /*   存放整数字符串   */
      int   i;
      InitStack(&OPTR);   /*   初始化运算符栈   */
      Push(&OPTR, '=');   /*   =是表达式结束标志   */
      InitStack(&OPND);   /*   初始化运算数栈   */
      c=getchar();
      GetTop(OPTR,&x);
      while(c!='='||x!='=')
      {
          if(In(c))   /*   是7种运算符之一   */
              switch(Precede(x,c))
              {
                  case '<':Push(&OPTR,c);   /*   栈顶元素优先权低   */
                                  c=getchar();
                                  break;
                  case '=':Pop(&OPTR,&x);   /*   脱括号并接收下一字符   */
                                  c=getchar();
                                  break;
                  case '>':Pop(&OPTR,&theta);   /*   退栈并将运算结果入栈   */
                                  Pop(&OPND,&b);
                                  Pop(&OPND,&a);
                                  Push(&OPND,Operate(a,theta,b));
              }
          else if(c>='0'&&c<='9')   /*   c是操作数   */
          {
              i=0;
              do
              {
                  z[i]=c;
                  i++;
                  c=getchar();
              }while(c>='0'&&c<='9');
              z[i]=0;
              d=atoi(z);   /*   将字符串数组转为整型存于d   */
              Push(&OPND,d);
          }
          else   /*   c是非法字符   */
          {
              printf( "ERROR3\n");
              exit(ERROR);
          }
          GetTop(OPTR,&x);
      }
      GetTop(OPND,&x);
      return  x;
  } 

  int main()
  {
      printf( "请输入算术表达式,负数要用(0-正数)表示,并以=结束\n");
      printf( "%d\n",EvaluateExpression());
      return 0;
  }