[开发测试]2021-07-30 KY129 浙大机试题简单计算器----编译原理思路

KY129 简单计算器

描述
读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。
输入描述：
测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。
输出描述：
对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。
示例1
输入：
1 + 2
4 + 2 * 5 - 7 / 11
0
输出：
3.00
13.36

思路：采用编译原理算符优先文法的思路

#include<bits/stdc++.h>
using namespace std;

const int maxStr = 202;
char str[maxStr];
stack<int> opStack;
stack<double> numStack;
int opg[][5] = {
    0, -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,  -1, -1, -1, -1,
+   1,  1,  1,  -1, -1,
-   1,  1,  1,  -1, -1,
*   1,  1,  1,  1,  1,
/   1,  1,  1,  1,  1,
*/

//词法分析
void getSym(bool& isOp, int& wordValue, int &i) {
    char ch = str[i++];
    while (ch == ' ') {
        ch = str[i++];
    }
    if (isdigit(ch)) {
        int numValue = 0;
        numValue = ch - '0';
        ch = str[i++];
        while (isdigit(ch)) {
            numValue = numValue * 10 + (ch - '0');
            ch = str[i++];
        }
        i--;
        isOp = false;
        wordValue = numValue;
        return;
    }
    else if (ch == '+') {
        isOp = true;
        wordValue = 1;
        return;
    }
    else if (ch == '-') {
        isOp = true;
        wordValue = 2;
        return;
    }
    else if (ch == '*') {
        isOp = true;
        wordValue = 3;
        return;
    }
    else if (ch == '/') {
        isOp = true;
        wordValue = 4;
        return;
    }    
    else if (ch == '#') {
        isOp = true;
        wordValue = 0;
        return;
    }
}

int main() {
    int i;
    bool isOp;
    int wordValue;
    while (cin.getline(str, maxStr) && !(str[0] == '0' && strlen(str) == 1)) {
        str[strlen(str)] = '#';
        i = 0;
        while (!opStack.empty()) opStack.pop();
        while (!numStack.empty()) numStack.pop();
        //压入一个#（0）
        opStack.push(0);
        do {
            getSym(isOp, wordValue, i);
            if (isOp == false) {
                numStack.push(wordValue);
            }
            else {
                if (opg[opStack.top()][wordValue] == -1) {//小于则入栈
                    opStack.push(wordValue);
                }
                else if (opg[opStack.top()][wordValue] == 0) {
                    break;
                }
                else if (opg[opStack.top()][wordValue] == 1) {//大于的规约（计算）
                    double num2 = numStack.top();
                    numStack.pop();
                    double num1 = numStack.top();
                    numStack.pop();
                    int op = opStack.top();
                    opStack.pop();
                    i--;
                    double ans;
                    switch (op) {
                    case 1:
                        ans = num1 + num2;
                        numStack.push(ans);
                        break;
                    case 2:
                        ans = num1 - num2;
                        numStack.push(ans);
                        break;
                    case 3:
                        ans = num1 * num2;
                        numStack.push(ans);
                        break;
                    case 4:
                        ans = num1 / num2;
                        numStack.push(ans);
                        break;
                    default:
                        break;
                    };
                }
            }
        } while (i < strlen(str));
        printf("%.2f\n", numStack.top());
    }
    return 0;
}