C++实现简单计算器

前言

在这个任务中，我们需要使用C++语言实现一个简单的计算器。计算器应该能够接受用户输入的表达式，并返回计算结果。我们将编写代码来解析表达式，执行相应的计算操作，并输出结果。

代码实现

#include 
#include 
#include 
#include 

using namespace std;

// 定义计算器类
class Calculator {
public:
    // 计算表达式结果的函数
    double calculateExpression(string expr) {
        stack operators;  // 运算符栈
        stack operands;  // 操作数栈

        for (int i = 0; i < expr.length(); i++) {
            char ch = expr[i];

            // 忽略空格
            if (ch == ' ') {
                continue;
            }

            // 如果是操作数，入栈操作数栈
            if (isdigit(ch)) {
                double num = ch - '0';
                operands.push(num);
            }

            // 如果是运算符
            else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
                // 一直计算与栈顶运算符优先级相同或更高的运算符
                while (!operators.empty() && precedence(operators.top()) >= precedence(ch)) {
                    double operand2 = operands.top();
                    operands.pop();
                    double operand1 = operands.top();
                    operands.pop();

                    char op = operators.top();
                    operators.pop();

                    double result = performOperation(op, operand1, operand2);
                    operands.push(result);
                }
                // 将当前运算符入栈
                operators.push(ch);
            }

            // 如果是括号
            else if (ch == '(') {
                operators.push(ch);
            } else if (ch == ')') {
                // 计算到前一个左括号为止
                while (operators.top() != '(') {
                    double operand2 = operands.top();
                    operands.pop();
                    double operand1 = operands.top();
                    operands.pop();

                    char op = operators.top();
                    operators.pop();

                    double result = performOperation(op, operand1, operand2);
                    operands.push(result);
                }
                // 弹出左括号
                operators.pop();
            }
        }

        // 计算剩余的操作符
        while (!operators.empty()) {
            double operand2 = operands.top();
            operands.pop();
            double operand1 = operands.top();
            operands.pop();

            char op = operators.top();
            operators.pop();

            double result = performOperation(op, operand1, operand2);
            operands.push(result);
        }

        return operands.top();  // 返回最终结果
    }

private:
    // 定义运算符优先级
    int precedence(char op) {
        if (op == '+' || op == '-') {
            return 1;
        } else if (op == '*' || op == '/') {
            return 2;
        }
        return 0;
    }

    // 执行运算
    double performOperation(char op, double operand1, double operand2) {
        double result = 0;
        switch (op) {
            case '+':
                result = operand1 + operand2;
                break;
            case '-':
                result = operand1 - operand2;
                break;
            case '*':
                result = operand1 * operand2;
                break;
            case '/':
                result = operand1 / operand2;
                break;
        }
        return result;
    }
};

int main() {
    Calculator calculator;
    string expression;

    cout << "请输入表达式：";
    getline(cin, expression);

    double result = calculator.calculateExpression(expression);
    cout << "计算结果：" << result << endl;

    return 0;
}

代码解释

我们首先定义了一个Calculator类，并在其中实现了calculateExpression函数。这个函数接受用户输入的表达式作为参数，然后通过使用两个栈来计算表达式的结果。

我们使用一个运算符栈来存储运算符，并使用一个操作数栈来存储操作数。

我们迭代表达式的每个字符，并根据字符的类型执行相应的操作：

1. 如果字符是一个操作数，我们将其转换为数字，并将其压入操作数栈中。
2. 如果字符是一个运算符，我们与栈顶的运算符进行比较。
• 如果栈顶的运算符具有较高的优先级，我们从操作数栈中弹出两个操作数，并从运算符栈中弹出一个运算符，然后执行相应的计算操作，并将结果压入操作数栈中。
• 如果栈顶的运算符具有较低的优先级，我们将当前运算符入栈。
3. 如果字符是一个左括号，我们将其压入运算符栈中。
4. 如果字符是一个右括号，我们从栈顶一直计算到遇到左括号为止。我们从操作数栈中弹出两个操作数，并从运算符栈中弹出一个运算符，然后执行相应的计算操作，并将结果压入操作数栈中。最后，弹出左括号。

在迭代结束后，我们将计算剩余的操作符，直到运算符栈为空。

最后，我们返回操作数栈顶的元素作为最终结果。

总结

通过这个代码实现，我们成功地实现了一个简单的计算器，它可以接受用户输入的表达式并返回计算结果。这个计算器使用栈数据结构来解析表达式，并根据运算符的优先级进行相应的计算操作。

需要注意的是，这个实现只能处理简单的四则运算，并不支持复杂的函数、变量等功能。但它提供了一个基本框架，可以扩展和改进来满足更复杂的需求。