算术表达式求值

写了个算术表达式求值，有些缺陷，输入运算数时只能输入0~9。

 

#include  < stdio.h >
#include  < stdlib.h >
#define STACK_INIT_SIZE  100
#define STACKINCREMENT  10
#define OVERFLOW  - 2
#define INFEASIBLE  - 1
#define ERROR  0
#define OK  1
#define TRUE  1
#define FALSE  0
typedef struct     // 运算符栈
... {
    char *base;
    char *top;
    int stacksize;
} SqStack;
typedef struct     // 运算数栈
... {
    int *base;
    int *top;
    int stacksize;
} sqStack;

// 一些栈的基本操作

int  InitStack(SqStack *  sq)
... {
    sq->base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));
    if(!sq->base)exit(OVERFLOW);
    sq->top=sq->base;
    sq->stacksize=STACK_INIT_SIZE;
    return OK;
}
int  initStack(sqStack *  sq)
... {
    sq->base=(int*)malloc(STACK_INIT_SIZE*sizeof(int));
    if(!sq->base)exit(OVERFLOW);
    sq->top=sq->base;
    sq->stacksize=STACK_INIT_SIZE;
    return OK;
}

char  GetTop(SqStack *  sq, char *  e)
... {
    if(sq->base==sq->top)return ERROR;
        *e=*(sq->top-1);
        return (*e);
}   // GetTop

int  getTop(sqStack *  sq, int *  e)
... {
    if(sq->base==sq->top)return ERROR;
        *e=*(sq->top-1);
        return (*e);
}   // getTop

int  Push(SqStack *  sq, char  e)
... {
    if(sq->top-sq->base>=sq->stacksize)
    ...{
        sq->base=(char*)realloc(sq->base,(sq->stacksize+STACKINCREMENT)*sizeof(char));
        if(!sq->base)exit(OVERFLOW);
        sq->top=sq->base+sq->stacksize;
        sq->stacksize+=STACKINCREMENT;
    }
    *sq->top++=e;
    return OK;
} // Push

int  push(sqStack *  sq, int  e)
... {
    if(sq->top-sq->base>=sq->stacksize)
    ...{
        sq->base=(int*)realloc(sq->base,(sq->stacksize+STACKINCREMENT)*sizeof(int));
        if(!sq->base)exit(OVERFLOW);
        sq->top=sq->base+sq->stacksize;
        sq->stacksize+=STACKINCREMENT;
    }
    *sq->top++=e;
    return OK;
} // push


int  Pop(SqStack *  sq, char *  e)
... {
    if(sq->base==sq->top)return ERROR;
      *e=*--sq->top;
    return OK;
} // Pop

int  pop(sqStack *  sq, int *  e)
... {
    if(sq->base==sq->top)return ERROR;
      *e=*--sq->top;
    return OK;
} // pop


char  Compare( char  t1, char  t2)   // 判断两个运算符的优先关系
... {
    char  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 ");
                exit(ERROR);
              }
              else
                f='<';
              break;
     case ')':switch(t1)
              ...{
            case '(':f='=';
                break;
            case '#':printf("ERROR2 ");
                exit(ERROR);
            default: f='>';
              }
            break;
     case '#':switch(t1)
          ...{
        case '#':f='=';
             break;
        case '(':printf("ERROR3 ");
             exit(ERROR);
        default: f='>';
           }
   }/**//*switch(t2)*/
   return f;
} /**/ /*Compare*/

int  In( char  c)  // 判断c是否为运算符
... {
    switch(c)
    ...{
     case'+':
     case'-':
     case'*':
     case'/':
     case'(':
     case')':
     case'#':return TRUE;
     default:return FALSE;
    }
} /**/ /*In*/

int  Operate( int  a, char  theta, int  b)      // 运算
... {
    int c;
    switch(theta)
    ...{
        case'+':c=a+b;
             break;
        case'-':c=a-b;
             break;
        case'*':c=a*b;
             break;
        case'/':c=a/b;
    }
    return c;
} /**/ /*Operate*/

int  GetNumber( char *  e)    // 字符型转整型
... {
   int n;
   if(48<=(*e)<=57)
   *e-=48;
   n=(int)*e;
   return n;
}

int  ExpEvaluation()    //  算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈
... {
    SqStack OPTR;
    sqStack OPND;
    char c,x,theta;
    int n,m,a,b;
    InitStack(&OPTR);Push(&OPTR,'#'); //‘#’号入栈便于运算
    initStack(&OPND);
    c=getchar();
    GetTop(&OPTR,&x);
    while(c!='#'||x!='#')
    ...{
        if(!In(c))     // 是7种运算符之一
        ...{
            n=GetNumber(&c);
            push(&OPND,n);
            c=getchar();
        }
        else
            switch(Compare(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));
                    break;
            }/**//*switch*/
        GetTop(&OPTR,&x);
    }/**//*while*/
    return (getTop(&OPND,&m));
}

void  main()
... {
    printf("请输入算术表达式（输入的运算数0~~9）,并以#结束 ");
    printf("%d ",ExpEvaluation());
}