用栈计算带括号的四则运算逻辑（最基础最细致）

首先声明俩个栈来存放 需要进行运算的数字 和 用于运算的运算符，顺带声明一下后面需要作为下标用到的i 和 用于临时存储的temp

stack<int> num;
stack<char> opt;
int i=0,temp=0;

然后我们将字符串中存储的算术式读取进入对应的num和opt

（isdigit函数用于检测字符是否为数字字符，即'0'到'9'，在cctype库头文件中

如果不嫌麻烦写expression[i]>='0'&&expression[i]<='9'也是没有问题的）

while (i < expression.size()) {
        if (isdigit(expression[i])) {    //数字字符
            temp = 0;
            while (i < expression.size() && isdigit(expression[i])) {
                temp = temp * 10 + (expression[i] - '0');  
                //temp*10往前移动一位，得到十位，然后用ASCII码计算得int，得到个位，递归
                i++;    //将下标移动至后一位
            }
            num.push(temp);    //得到完整的单个'数字块'，并进入num
        }

接下来就是运算符的问题了，众所周知，+-的优先级是要低于*/的，而()是最高优先级，所以为了评判谁应该先计算，我们需要创建一个prio的优先级函数

int prio(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

而因为有括号，有时我们需要读取到括号立刻计算，所以为了后续的计算，我们再创建一个用于计算的函数compute

void compute(stack<int>& num, stack<char>& opt) {
    int num1 = num.top(); num.pop();
    //取num栈顶元素，并将其pop，以得到num2
    int num2 = num.top(); num.pop();
    char op = opt.top(); opt.pop();

    switch (op) { //将计算所得的数再push入num，用于下一次计算，也是通过top能读取结果的原因
        case '+': num.push(num2 + num1); break;
        case '-': num.push(num2 - num1); break;
        case '*': num.push(num2 * num1); break;
        case '/': num.push(num2 / num1); break;
    }
}

接下来，我们就能继续写主函数了，运算符的读取需要分两部分，因为括号的优先级最高，所以我们先写括号的逻辑

else if (expression[i] == '(') {
            opt.push(expression[i]);
            i++;
        } else if (expression[i] == ')') {
            while (!opt.empty() && opt.top() != '(') {    //在括号内按运算优先级计算
                compute(num, opt);
            }
            if (!opt.empty()) opt.pop();    //计算到左括号时直接pop
            i++;
        } 

然后，我们只需读取+-*/就可以了

else {
            while (!opt.empty() && prio(expression[i]) <= prio(opt.top())) {
            //没有括号的情况下，正常按优先级运算，栈顶优先级大就让栈顶先运算
                compute(num, opt);
            }
            opt.push(expression[i]);    //让运算符进入opt
            i++;
        }
    }

最后，很关键的一步，我们需要把栈内的所有运算符都计算掉，才能结束！

while (!opt.empty()) {
        compute(num, opt);
    }

剩余的输入输出代码我直接放在完整代码里了，大家自己看吧，其实应该把这个算术式计算封装为一个函数更好，也更整洁，大家可以按自己理解优化一下，下面是完整代码：

#include <iostream>
#include <stack>
#include <string>
#include <cctype>
using namespace std;

int prio(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

void compute(stack<int>& num, stack<char>& opt) {
    int num1 = num.top(); num.pop();
    int num2 = num.top(); num.pop();
    char op = opt.top(); opt.pop();

    switch (op) {
        case '+': num.push(num2 + num1); break;
        case '-': num.push(num2 - num1); break;
        case '*': num.push(num2 * num1); break;
        case '/': num.push(num2 / num1); break;
    }
}

int main(){
	string expression;
	cout<<"请输入表达式";
	cin>>expression;
    stack<int> num;
    stack<char> opt;
    int i = 0, temp = 0;
    while (i < expression.size()) {
        if (isdigit(expression[i])) {
            temp = 0;
            while (i < expression.size() && isdigit(expression[i])) {
                temp = temp * 10 + (expression[i] - '0');
                i++;
            }
            num.push(temp);
        } else if (expression[i] == '(') {
            opt.push(expression[i]);
            i++;
        } else if (expression[i] == ')') {
            while (!opt.empty() && opt.top() != '(') {
                compute(num, opt);
            }
            if (!opt.empty()) opt.pop();
            i++;
        } else {
            while (!opt.empty() && prio(expression[i]) <= prio(opt.top())) {
                compute(num, opt);
            }
            opt.push(expression[i]);
            i++;
        }
    }
    while (!opt.empty()) {
        compute(num, opt);
    }
    int res=num.top();
    cout<<"计算得："<<res<<endl;
	return 0; 
}