实现输入一个中缀算术表达式，通过转换成后缀表达式来计算结果

#include <iostream>
#include <stack>
#include <string>
#include <sstream>
#include <vector>
#include <cctype>

using namespace std;

// 判断是否为操作符
bool isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}

// 判断操作符的优先级
int precedence(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

// 中缀表达式转换为后缀表达式
vector<string> infixToPostfix(const string &infix) {
    stack<char> s;                // 操作符栈
    vector<string> postfix;       // 存储后缀表达式
    string number;                // 临时存储多位数字
    for (char c : infix) {
        if (isdigit(c)) {         // 如果字符是数字，构建数字字符串
            number += c;
        } else {                  // 如果字符是操作符或括号
            if (!number.empty()) { // 将前面的数字字符串加入后缀表达式
                postfix.push_back(number);
                number.clear();   // 清空临时存储
            }
            if (c == '(') {       // 如果是左括号，压入栈
                s.push(c);
            } else if (c == ')') { // 如果是右括号，将栈顶操作符弹出直到遇到左括号
                while (!s.empty() && s.top() != '(') {
                    postfix.push_back(string(1, s.top()));
                    s.pop();
                }
                s.pop();          // 弹出左括号
            } else if (isOperator(c)) { // 如果是操作符
                while (!s.empty() && precedence(s.top()) >= precedence(c)) {
                    postfix.push_back(string(1, s.top())); // 将优先级更高或相等的操作符弹出
                    s.pop();
                }
                s.push(c);        // 将当前操作符压入栈
            }
        }
    }
    if (!number.empty()) {        // 将最后一个数字加入后缀表达式
        postfix.push_back(number);
    }
    while (!s.empty()) {          // 将栈中剩余的操作符弹出
        postfix.push_back(string(1, s.top()));
        s.pop();
    }
    return postfix;
}

// 计算后缀表达式的值
int evaluatePostfix(const vector<string> &postfix) {
    stack<int> s;                 // 存储操作数的栈
    for (const string &token : postfix) {
        if (isdigit(token[0])) {  // 如果是数字，转换并压入栈
            s.push(stoi(token));
        } else {                  // 如果是操作符
            int val2 = s.top(); s.pop(); // 弹出两个操作数
            int val1 = s.top(); s.pop();
            switch (token[0]) {    // 根据操作符进行计算，并将结果压入栈
                case '+': s.push(val1 + val2); break;
                case '-': s.push(val1 - val2); break;
                case '*': s.push(val1 * val2); break;
                case '/': s.push(val1 / val2); break;
            }
        }
    }
    return s.top();               // 栈顶即为计算结果
}

int main() {
    string infix;
    cout << "Enter an infix expression: ";
    getline(cin, infix);          // 读取中缀表达式

    vector<string> postfix = infixToPostfix(infix); // 转换为后缀表达式

    cout << "Postfix expression: ";
    for (const string &token : postfix) {
        cout << token << ' ';     // 输出后缀表达式
    }
    cout << endl;

    int result = evaluatePostfix(postfix); // 计算后缀表达式的值
    cout << "Result: " << result << endl;  // 输出结果

    return 0;
}