注意：运行时输入格式：5+2*6#  ，接着按回车键
程序缺陷：输入 20+5*3#  的运行结果则计算不了。

#include "stdafx.h"
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

#define STACK_INIT_SIZE    100
typedef struct tagSqStack{
    int *base;                                        // 栈底
    int *top;                                        // 栈顶
    int stacksize;
} SqStack;

int InitStack(SqStack &);                            // 创建栈
void Push(SqStack &, int);                            // 向栈中放入数据[压栈]
void Pop(SqStack &, int &);                            // 从栈中取数据[弹栈]
int  GetTop(SqStack &);                                // 查看栈顶数据

int GetOperatorID(char);                            // 取运算符在数组中的对应位置
char Precede(char, char);                            // 比较运算符的优先级
void EvaluateExpression(void);                        // 求运算表达式的值

int main(int argc, char* argv[])                    // 主函数
{
    EvaluateExpression();
    return 0;
}

int InitStack(SqStack &S)                            // 创建栈
{
    S.base = (int *)malloc(STACK_INIT_SIZE*sizeof(int));
    if (!S.base) return(-1);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return(1);
}

void Push(SqStack &S, int e)                        // 向栈中放入数据[压栈]
{
    *S.top = e;
    S.top++;
}

void Pop(SqStack &S, int &e)                        // 从栈中取数据[弹栈]
{
    if (S.top == S.base) return;
    S.top--;
    e = *S.top;
}

int GetTop(SqStack &S)                                // 查看栈顶数据            
{
    if (S.top == S.base) return('E');
    return(*(S.top-1));
}

//提示：运算符之间的优先级可以用一个二维数组存储起来，并且用0表示+，1表示-，2表示*，3表示/，4表示(，5表示)，6表示#，则53页表3.1运算符间的优先关系可以表示如下：
//                               +    -    *    /    (    )    #
char OperatorPrecede[7][7]={'>', '>', '<', '<', '<', '>', '>',     // +
                            '>', '>', '<', '<', '<', '>', '>',     // -
                            '>', '>', '>', '>', '<', '>', '>',     // *
                            '>', '>', '>', '>', '<', '>', '>',     // /
                            '<', '<', '<', '<', '<', '=', 'E',     // (
                            '>', '>', '>', '>', 'E', '>', '>',     // )
                            '<', '<', '<', '<', '<', 'E', '='};    // #


char Precede(char Operator1, char Operator2)        // 比较运算符的优先级
{
    int OperatorID1, OperatorID2;

    OperatorID1 = GetOperatorID(Operator1);
    OperatorID2 = GetOperatorID(Operator2);
    if (OperatorID1 < 0 || OperatorID1 > 6 || OperatorID2 < 0 || OperatorID2 > 6) return('E');  
    return(OperatorPrecede[OperatorID1][OperatorID2]);
}

int GetOperatorID(char Operator)                    // 取运算符在数组中的对应位置
{
    int retCode;

    retCode = -1;
    switch(Operator) {
        case '+': retCode = 0; break;
        case '-': retCode = 1; break;
        case '*': retCode = 2; break;
        case '/': retCode = 3; break;
        case '(': retCode = 4; break;
        case ')': retCode = 5; break;
        case '#': retCode = 6; break;
    }
     return(retCode);
}

void EvaluateExpression()                            // 求运算表达式的值
{
    int a, b, x, theta;
    char c;
    SqStack OPTR, OPND;
    int result;

    if (InitStack(OPTR) == -1) printf("Error OPTR");// 创建运算符栈
    if (InitStack(OPND) == -1) printf("Error OPND");// 创建操作数栈


    Push(OPTR, '#');
    c = getchar();                                    // 从运算式中取第一个字符

    while((c != '#') || (GetTop(OPTR) != '#')) {    // 如果是结束字符'#'，则结束
        if ((c >= '0') && (c<= '9')) {                // 是操作数，则进操作数栈
            Push(OPND, c-'0');                        // 将字符变为数据
            c = getchar();
        }   
        else {
            switch(Precede(GetTop(OPTR), 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);                // 从操作数栈中退出两个操作数
                          switch(theta) {            // 加、减、乘、除运算
                              case '+': result = a+b; break;
                              case '-': result = a-b; break;
                              case '*': result = a*b; break;
                              case '/': result = a/b; break;
                          }
                          Push(OPND, result);        // 运算结果入栈
                          break;
            }
   
        }
    }

    result = GetTop(OPND);
    printf("The result=%d\n", result);
}

有没有人能解释一下这个程序啊？

刚好前几天我也在做这个，表达式求值嘛，我给我的部分函数你参考下，就是在判断字符是不是操作数那里，加多几步，判断下一个数是不是操作数，如果是，前一个就要乘以10再加上这个，知道读入操作符，才把操作数进栈。

int EvaluateExpression()
{
    int sum;
    SElemType a,b,theta,x;
    char c;
    SqStack OPTR,OPND;
    InitStack(OPTR);
    Push(OPTR,'#');
    InitStack(OPND);
    c=getchar();
    while(c!='='||GetTop(OPTR)!='#')
    {
        if(!In(c))  //判断是不是操作数
        {
            sum=0;
            sum=c-'0';
            c=getchar();
            while(!In(c))   //判断下一个是不是操作数
            {
                sum=sum*10+(c-'0');  //把几个操作数转化成真正的数，如连续读入‘2’，‘0’，则2*10+0=20
                c=getchar();
            }
            Push(OPND,sum);
        }
        else 
            switch(Precede(GetTop(OPTR),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;
        }
    }
        return GetTop(OPND);
}