堆栈的应用之计算数学表达式

下面的代码主要实现了以下功能：
输入数学表达式，输出表达式的计算结果。数学表达式由单个数字和运算符“+”、“-”、“”、“/”、“(、“)构成，例如 2 + 3 ( 4 + 5 ) – 6 / 4。假定表达式输入格式合法。

#include   
#include 
#include 
#include   
using namespace std;  

char OP[7] = {'+','-','*','/','(',')','#'};  //运算符集合  
int priority[7][7] =     //各运算符相遇时，优先级比较 1:大于，2:小于，3:等于，0:不可能，错误  
{  
    { 1, 1, 2, 2, 2, 1, 1 },  
    { 1, 1, 2, 2, 2, 1, 1 },  
    { 1, 1, 1, 1, 2, 1, 1 },  
    { 1, 1, 1, 1, 2, 1, 1 },  
    { 2, 2, 2, 2, 2, 3, 0 },  
    { 1, 1, 1, 1, 0, 1, 1 },  
    { 2, 2, 2, 2, 2, 0, 3 }  
};  
bool isOpat(char c)   //是否是OP[]中的操作符  
{  
    for (int i = 0; i < 7; i++)  
    {  
        if (c == OP[i])  
            return true;  
    }  
    return false;  
}  
int getPriority(char c1,char c2)  //比较优先级  
{  
    int i, j;  
    for (int r = 0; r < 7; r++)  
    {  
        if (c1 == OP[r])  
            i = r;  
        if (c2 == OP[r])  
            j = r;  
    }  
    return priority[i][j];  
}  
int compute(char a, char op, char b)  
{  
    switch (op)  
    {  
    case '+':  
        return (a - '0') + (b - '0');  
    case '-':  
        return (a - '0') - (b - '0');  
    case '*':  
        return (a - '0')*( b - '0');  
    case '/':  
        if (b == '0')  
        {  
            cout << "错误！" << endl;  
            exit(0);  
        }  
        return (a - '0')/(b - '0');  
    }  
}  
void evaluateExpression()   //计算  
{  
    stack<char> opan,opat;    //构建两个栈 operand:操作数，operator:操作符  
    opat.push('#');    // # 压入符号栈，作为界限符  
    cout << "输入算术表达式" << endl;  
    char op,a,b,c;  
    c=getchar();  
    while (c != '#' || opat.top() != '#')  //没有读到 '#'，或者符号栈也没空，则继续读取字符  
    {  
        //对读入的字符进行判断：是操作数还是操作符？  
        if (!isOpat(c))  //是操作数则压入操作数栈  
        {  
            opan.push(c);  
            c = getchar();  
        }  
        else   //若是操作符，则需把符号栈顶的操作符与当前读入的操作符，进行优先级比较  
        {  
            switch(getPriority(opat.top(), c))  
            {  
            case 1:  
                op = opat.top(); opat.pop();  
                b = opan.top(); opan.pop();  
                a = opan.top(); opan.pop();  
                opan.push(char(compute(a,op,b)+'0'));  
                break;  
            case 2:  
                opat.push(c);  
                c = getchar();  
                break;  
            case 3:  
                opat.pop();  
                c = getchar();  
                break;  
            case 0:  
                cout << "错误！" << endl;  
                exit(0);  
            }  
        }  
    }  
    cout << "= " << opan.top()-'0' << endl;  
}  
int main()  
{  
    cout << "使用栈结构解析计算表达式"<"pause");  
    return 0;  
}