表达式求值（栈方法/C++语言描述）（一）

　　一个算数表达式（以下简称为表达式）由运算数、运算符、左括号和右括号组成，定义一个枚举类型TokenType表示为：

typedef enum {
    BEGIN,
    NUMBER,
    OPERATOR,
    LEFT_BRAC,
    RIGHT_BRAC
} TokenType;

BEGIN用来表示表达式的开始，稍后会再提及到它。

　　对表达式进行求值需要借助数据结构栈，C++的标准模板库中包含stack类型，只需要包含头文件stack并引用命名空间std就可以使用了。整个求值过程总共需要2个栈，分别用来存储运算数和运算符；基本求值过程是这样的：比较当前运算符和运算符栈中栈顶运算符的优先级，若栈顶运算符优先级高于当前运算符，则从运算数栈中弹出两个运算数，使用运算符栈栈顶运算符进行计算后再压入运算数栈，并将当前运算符压入运算符栈，否则只将当前运算符压入运算符栈；最后反复上述运算压栈过程直至运算符栈为空，运算数栈的栈顶元素即为运算结果。Calculator类声明如下：

class Calculator
{
public:
    double calculate(string expression) throw(string);

private:
    stack<double> _stkNumbers;
    stack<char> _stkOperators;

    static int priority(char op);
    static double calculate(double d1, char op, double d2) throw(string);

    void calculateStack() throw(string);
    void dealWithNumber(char *&pToken) throw(string);
    void dealWithOperator(char *&pToken) throw(string);
    void dealWithLeftBrac(char *&pToken) throw(string);
    void dealWithRightBrac(char *&pToken) throw(string);
};

使用代码描述的运算压栈过程如下：

void Calculator::calculateStack() throw (string) {
    double d2 = _stkNumbers.top();
    _stkNumbers.pop();
    double d1 = _stkNumbers.top();
    _stkNumbers.pop();
    char op = _stkOperators.top();
    _stkOperators.pop();
    _stkNumbers.push(calculate(d1, op, d2));
}

静态成员函数calculate()用于进行简单的四则运算，同时也处理了除数为0的情况：

double Calculator::calculate(double d1, char op, double d2) throw (string) {
    assert(op == '+' || op == '-' || op == '*' || op == '/');

    cout << d1 << op << d2 << endl;

    if (op == '+') {
        return d1 + d2;
    } else if (op == '-') {
        return d1 - d2;
    } else if (op == '*') {
        return d1 * d2;
    } else {
        if (!d2) {
            throw string("divided by 0");
        }
        return d1 / d2;
    }
}

　　此外，根据数学规则，有：

• 表达式只能以左括号或运算数开始；
• 运算数后只能是右括号或运算符；
• 运算符或左括号后只能是左括号或运算数；
• 右括号后只能是另一个右括号或运算符。

使用代码描述这些数学规则和最后清空运算符栈的过程如下：

double Calculator::calculate(string expression) throw (string) {
    while (!_stkNumbers.empty()) {
        _stkNumbers.pop();
    }
    while (!_stkOperators.empty()) {
        _stkOperators.pop();
    }
    TokenType lastToken = BEGIN;

    char * pToken = &expression[0];
    while (*pToken) {
        switch (lastToken) {
        case BEGIN:
            if (*pToken == '(') {
                // an expression begin with a left bracket
                dealWithLeftBrac(pToken);
                lastToken = LEFT_BRAC;
            } else {
                // or a number
                dealWithNumber(pToken);
                lastToken = NUMBER;
            }
            break;
        case NUMBER:
            // after a number
            if (*pToken == ')') {
                // it may be a right bracket
                dealWithRightBrac(pToken);
                lastToken = RIGHT_BRAC;
            } else {
                // it may be an operator
                dealWithOperator(pToken);
                lastToken = OPERATOR;
            }
            break;
        case OPERATOR:
        case LEFT_BRAC:
            // after an operator or a left bracket
            if (*pToken == '(') {
                // it may be a left bracket
                dealWithLeftBrac(pToken);
                lastToken = LEFT_BRAC;
            } else {
                // it may be a number
                dealWithNumber(pToken);
                lastToken = NUMBER;
            }
            break;
        case RIGHT_BRAC:
            // after a right bracket
            if (*pToken == ')') {
                // it may be another right bracket
                dealWithRightBrac(pToken);
                lastToken = RIGHT_BRAC;
            } else {
                // it may be an operator
                dealWithOperator(pToken);
                lastToken = OPERATOR;
            }
            break;
        }
    }

    while (!_stkOperators.empty()) {
        if (_stkOperators.top() == '(') {
            throw string("bad token '('");
        }
        calculateStack();
    }

    assert(!_stkNumbers.empty());
    return _stkNumbers.top();
}

lastToken用来指示上一个token的类型，它应该被初始化为BEGIN；在开始求值之前清空运算符栈和运算数栈，可以防止出错，是很有必要的。