假定算数表达式的值均为非负整数常数，不包含变量、小 数和字符常量。 试设计一个算术四则运算表达式求值的简单计算器。 基本要求： 1、 操作数均为非负整数常数，操作符仅为+、-、*、/、（和）； 2、 编写 main 函数进行测试。给出详细注释

### 回答1：
好的，我明白了。以下是对您的问题的回答：

对于这个问题，我们可以使用栈来实现表达式的求值。具体的实现步骤如下：

1. 定义两个栈，一个用来存放操作数，另一个用来存放操作符。
2. 从左到右遍历表达式，依次读取每个字符。
3. 如果当前字符是数字，则将它转换为整数，并将其压入操作数栈中。
4. 如果当前字符是操作符，则将它压入操作符栈中。
5. 如果当前字符是右括号，则弹出操作符栈中的操作符，直到遇到左括号为止。每次从操作数栈中弹出两个数，并根据操作符进行计算，将结果压入操作数栈中。
6. 如果表达式遍历完毕，则弹出操作符栈中的操作符，每次从操作数栈中弹出两个数，并根据操作符进行计算，将结果压入操作数栈中。最后，操作数栈中只剩下一个数，即为表达式的值。

下面是简单计算器的实现代码：

#include <iostream>
#include <stack>
#include <cstdlib>
using namespace std;

int main() {
    stack<int> numStack;    // 存储操作数的栈
    stack<char> opStack;    // 存储操作符的栈
    string expr;            // 算数表达式
    int len;                // 算数表达式的长度
    char opt;               // 当前字符

    // 读入算数表达式
    cout << "请输入算数表达式：";
    cin >> expr;
    len = expr.size();

    // 依次读取算数表达式中的每个字符
    for (int i = 0; i < len; i++) {
        opt = expr[i];
        if (isdigit(opt)) {                             // 如果当前字符是数字
            int num = opt - '0';
            numStack.push(num);
        } else if (opt == '(' || opt == '+' || opt == '-') {     // 如果当前字符是左括号、加号或减号
            opStack.push(opt);
        } else if (opt == '*' || opt == '/') {            // 如果当前字符是乘号或除号
            while (!opStack.empty() && opStack.top() != '(' && opStack.top() != '+' && opStack.top() != '-') {
                char op = opStack.top();
                opStack.pop();
                int num2 = numStack.top();
                numStack.pop();
                int num1 = numStack.top();
                numStack.pop();
                int res;
                if (op == '*') {
                    res = num1 * num2;
                } else {
                    res = num1 / num2;
                }
                numStack.push(res);
            }
            opStack.push(opt);
        } else if (opt == ')') {                          // 如果当前字符是右括号
            while (opStack.top() != '(') {
                char op = opStack.top();
                opStack.pop();
                int num2 = numStack.top();
                numStack.pop();
                int num1 = numStack.top();
                numStack.pop();
                int res;
                if (op == '+') {
                    res = num1 + num2;
                } else {
                    res = num1 - num2;
                }
                numStack.push(res);
            }
            opStack.pop();  // 弹出左括号
        }
    }

    // 处理剩余的操作符
    while (!opStack.empty()) {
        char op = opStack.top();
        opStack.pop();
        int num2 = numStack.top();
        numStack.pop();
        int num1 = numStack.top();
        numStack.pop();
        int res;
        if (op == '+') {
            res = num1 + num2;
        } else {
            res = num1 - num2;
        }
        numStack.push(res);
    }

    // 输出表达式的值
    cout << "表达式的值为：" << numStack.top() << endl;

    return 0;
}

好了，以上就是简单计算器的实现方法。希望能对您有所帮助。如果您还有其他问题，可以继续向我提问。

### 回答2：
算术四则运算表达式求值的简单计算器的设计如下：

首先定义一个函数 eval(expr)，接受一个算术四则运算表达式expr作为参数，返回表达式的计算结果。

在eval函数中，我们使用了一个栈来储存运算符和操作数。首先，我们初始化一个空栈。

然后，我们从表达式的左边开始逐个遍历字符。如果遇到一个数字，我们将该数字转换为整数，并将其压入栈中。

接下来，如果遇到一个操作符，我们需要根据操作符的优先级判断是否需要进行计算。这里我们使用了两个辅助函数，分别是优先级比较函数priority(op1, op2)和计算函数calculate(num1, num2, op)。

优先级比较函数priority(op1, op2)返回op1和op2两个操作符的优先级比较结果。其中，“*”和“/”的优先级较高，返回1；“+”和“-”的优先级较低，返回-1；括号“（”的优先级最低，返回-2。

计算函数calculate(num1, num2, op)接受两个操作数num1和num2以及一个操作符op作为参数，并返回计算结果。根据操作符的不同，进行相应的计算并返回结果。

在eval函数中，当遇到一个操作符时，我们首先判断栈顶的操作符和当前遍历到的操作符的优先级。如果栈顶的操作符的优先级大于等于当前遍历到的操作符的优先级，我们从栈顶将操作符弹出，并从栈中弹出两个操作数进行计算，并将计算结果压入栈中。直到栈顶的操作符的优先级小于当前遍历到的操作符的优先级，或者栈为空，我们将当前遍历到的操作符压入栈中。

最后，我们遍历完整个表达式后，只剩下栈中的最后一个操作数，即为表达式的计算结果。我们将其弹出并作为eval函数的返回值。

在main函数中，我们可以输入一个算术四则运算表达式，调用eval函数进行计算，然后输出结果。

整体思路如上，具体代码实现请参考以下示例：

def priority(op1, op2):
    if op1 == "(" or op2 == "(":
        return -2
    if op1 in ["*", "/"] and op2 in ["+", "-"]:
        return 1
    else:
        return -1

def calculate(num1, num2, op):
    if op == "+":
        return num1 + num2
    elif op == "-":
        return num1 - num2
    elif op == "*":
        return num1 * num2
    elif op == "/":
        return num1 // num2

def eval(expr):
    stack = []
    i = 0

    while i < len(expr):
        if expr[i].isdigit():
            j = i
            while j < len(expr) and expr[j].isdigit():
                j += 1
            num = int(expr[i:j])
            stack.append(num)
            i = j
        elif expr[i] in ["+", "-", "*", "/"]:
            while stack and stack[-1] != "(" and priority(stack[-1], expr[i]) >= 0:
                num2 = stack.pop()
                num1 = stack.pop()
                op = stack.pop()
                res = calculate(num1, num2, op)
                stack.append(res)
            stack.append(expr[i])
            i += 1
        elif expr[i] == "(":
            stack.append(expr[i])
            i += 1
        elif expr[i] == ")":
            while stack[-1] != "(":
                num2 = stack.pop()
                num1 = stack.pop()
                op = stack.pop()
                res = calculate(num1, num2, op)
                stack.append(res)
            stack.pop()
            i += 1

    while len(stack) > 1:
        num2 = stack.pop()
        num1 = stack.pop()
        op = stack.pop()
        res = calculate(num1, num2, op)
        stack.append(res)

    return stack[0]

def main():
    expr = input("请输入一个算术四则运算表达式：")
    result = eval(expr)
    print("计算结果为：", result)

if __name__ == "__main__":
    main()

编写main函数进行测试，在控制台输入一个算术四则运算表达式，例如"(3+4)*5/2"，则会输出计算结果为"17"。

### 回答3：
下面是一个求解算术四则运算表达式的简单计算器的设计示例：

#include<iostream>
#include<stack>

using namespace std;

int calculate(string s) {
    stack<int> nums; // 存储操作数的栈
    stack<char> ops; // 存储操作符的栈

    for(int i=0; i<s.length(); i++) {
        if (s[i] == ' ') continue; // 忽略空格

        if(isdigit(s[i])) { // 如果是数字
            int num = 0;
            while(i < s.length() && isdigit(s[i])) {
                num = num * 10 + (s[i] - '0');
                i++;
            }
            nums.push(num); // 将数字压入操作数栈
        }

        if(s[i] == '(') { // 如果是左括号
            ops.push(s[i]); // 将左括号压入操作符栈
        }

        if(s[i] == ')') { // 如果是右括号
            while(ops.top() != '(') { // 执行括号内的运算
                int num2 = nums.top();
                nums.pop();
                int num1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();

                int result;
                if(op == '+') result = num1 + num2;
                if(op == '-') result = num1 - num2;
                if(op == '*') result = num1 * num2;
                if(op == '/') result = num1 / num2;

                nums.push(result); // 将运算结果压入操作数栈
            }
            ops.pop(); // 弹出左括号
        }

        if(s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/') { // 如果是运算符
            while(!ops.empty() && isHighPriority(s[i], ops.top())) { // 判断优先级
                int num2 = nums.top();
                nums.pop();
                int num1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();

                int result;
                if(op == '+') result = num1 + num2;
                if(op == '-') result = num1 - num2;
                if(op == '*') result = num1 * num2;
                if(op == '/') result = num1 / num2;

                nums.push(result); // 将运算结果压入操作数栈
            }
            ops.push(s[i]); // 将当前运算符压入操作符栈
        }
    }

    while(!ops.empty()) { // 处理剩下的操作符
        int num2 = nums.top();
        nums.pop();
        int num1 = nums.top();
        nums.pop();
        char op = ops.top();
        ops.pop();

        int result;
        if(op == '+') result = num1 + num2;
        if(op == '-') result = num1 - num2;
        if(op == '*') result = num1 * num2;
        if(op == '/') result = num1 / num2;

        nums.push(result); // 将运算结果压入操作数栈
    }

    return nums.top(); // 返回最终计算结果
}

bool isHighPriority(char op1, char op2) {
    if(op2 == '(' || op2 == ')') return false; // 括号的优先级最高
    if((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) return false; // 高优先级
    return true; // 低优先级
}

int main() {
    string s = "3 + 5 * ( 4 - 2 )";
    int result = calculate(s);
    cout << result << endl; // 输出结果为 13
    return 0;
}

算术四则运算表达式求值的计算器，基本思路是使用两个栈，一个栈存储操作数，一个栈存储操作符。遇到数字时，将数字压入操作数栈；遇到左括号时，将左括号压入操作符栈；遇到右括号时，从操作数栈和操作符栈中取出相应的数字和操作符，进行运算，将结果压入操作数栈；遇到运算符时，从操作数栈和操作符栈中取出相应的数字和操作符，进行运算，将结果压入操作数栈。最后，将操作数栈的栈顶元素作为最终的计算结果返回即可。