在评估不带括号的简单数学表达式时保持运算顺序

Question

我正在用 C 语言创建一个计算器程序，它最多需要 5 个数字和 4 个运算，然后计算答案以更好地学习语言。我几乎所有东西都可以正常工作，只是它还没有遵循操作顺序。我能想到的唯一方法是通过将乘法和除法语句移到数组的前面，将加法和减法语句移到后面，以某种方式同时对运算和数字进行排序.但是，我完全不知道该怎么做，我认为这是一个非常安全的假设，即有更好、更有效的方法来完成这项任务。有谁在 C 方面有更多经验的人知道如何解决这个问题吗？

这是我目前的代码：

/* A calculator that accepts up to 5 numbers and performs
multiple mathematical operations on the given numbers. */

#include <stdio.h>
#include <stdlib.h>

/* Creating functions for each of
the basic mathematical operators */

double add(double x, double y) {
    /* Add variables x and y */
    return x + y;
}

double subtract(double x, double y) {
    /* Subtract variables x and y */
    return x - y;
}

double multiply(double x, double y) {
    /* Multiply variables x and y */
    return x * y;
}

double divide(double x, double y) {
    /* Divide variables x and y */
    return x / y;
}

/* "operation" typedef to point
to the above operator functions */
typedef double (*operation)(double, double);

int main() {
    double nums[5];
    char operator;
    operation operators[5];    // operator functions pointer array
    double result;
    int i = 0;    // index variable to be used for iteration

    printf("\n ################################\n");
    printf(" ########## Calculator ##########\n");
    printf(" ################################\n\n");
    printf(" You may enter up to 5 numbers in you calculation.\n");
    printf(" If you wish to enter fewer than 5 numbers, type an \"=\" as the operator after your final number.\n\n");

    while (i < 5) {
        // Getting the user's input
        printf(" Enter a number: ");
        scanf("%lf", &nums[i]);
        if (i == 4) {
            operators[i] = NULL;    // Sets the final operator to NULL
        } else {
            printf(" Enter an operator (+, -, *, /, or =): ");
            scanf(" %c", &operator);

            /* Switch statement to decide which function to run on
            the given numbers on each iteration through the loop */
            switch(operator) {
                case '+' :
                    operators[i] = add;
                    break;
                case '-' :
                    operators[i] = subtract;
                    break;
                case '*' :
                    operators[i] = multiply;
                    break;
                case '/' :
                    operators[i] = divide;
                    break;
                default :
                    operators[i] = NULL;
                    break;
            }
        }
        if (!operators[i]) break;    // Breaks out of the loop if the current operator is NULL
        i++;    // Increments the index variable up by 1
    }


    result = nums[0];
    for (i = 1; i < 5; i++) {
        if (operators[i - 1]) {
            result = operators[i - 1](result, nums[i]);
        } else {
            break;
        }
    }

    // Printing out the answer rounded to 2 decimal points
    printf("Result: %.2f\n", result);

    return 0;
}

如您所见，我在顶部有每个操作的函数，还有一个 while 循环，它接受一个数字和一个运算符，并使用 switch 语句将适当的函数插入到数组中。之后，我有一个for 循环，它遍历数组并按照输入的顺序执行操作。这就是导致答案在技术上不正确的原因，因为它对最后一次通过 for 循环产生的答案执行每个操作。这就是为什么我希望对数组中的操作进行排序。如果我可以在所有计算发生之前将所有操作和数字按正确的顺序排列，那么它将按照操作顺序并给出正确的答案。

这是我当前程序的输出示例：

################################
########## Calculator ##########
################################

You may enter up to 5 numbers in you calculation.
If you wish to enter fewer than 5 numbers, type an "=" as the operator after your final number.

Enter a number: 3
Enter an operator (+, -, *, /, or =): +
Enter a number: 6
Enter an operator (+, -, *, /, or =): -
Enter a number: 7
Enter an operator (+, -, *, /, or =): *
Enter a number: 3
Enter an operator (+, -, *, /, or =): /
Enter a number: 2
Result: 3.00
[Finished in 21.57s]

以下是我希望它提出的示例：

################################
########## Calculator ##########
################################

You may enter up to 5 numbers in you calculation.
If you wish to enter fewer than 5 numbers, type an "=" as the operator after your final number.

Enter a number: 3
Enter an operator (+, -, *, /, or =): +
Enter a number: 6
Enter an operator (+, -, *, /, or =): -
Enter a number: 7
Enter an operator (+, -, *, /, or =): *
Enter a number: 3
Enter an operator (+, -, *, /, or =): /
Enter a number: 2
Result: -1.50
[Finished in 21.57s]

有没有人能想到的方法来完成这个？

Answer 1

如果您在表达式中不支持括号，则问题会大大简化，您可以使用两次输入表达式来计算它。这里的保证是表达式树的深度永远不会超过 2 级。第一遍负责处理更高优先级的操作（乘法、除法）并确保这些操作以正确的符号完成。第二遍只是对剩余的部分应用加法和减法。

我假设参数可以改变，表达式被正确解析和验证，应用程序在被零除时崩溃，不处理溢出，为简单起见使用整数等，所以认为这只是一个快速而肮脏的证明 -概念的展示两遍表达式评估技术。

#include <stdio.h>

enum {ADD, SUB, MUL, DIV};
int _add(int a, int b) {return a + b;}
int _sub(int a, int b) {return a - b;}
int _mul(int a, int b) {return a * b;}
int _div(int a, int b) {return a / b;}
int (*ops[4])(int x, int y) = {_add, _sub, _mul, _div};

int eval_math_expr_without_parens(int len, int *e) {
    for (int i = 0; i < len - 2; i += 2) {
        if (e[i+1] == SUB) {
            e[i+1] = ADD;
            e[i+2] *= -1;
        }

        if (e[i+1] == MUL || e[i+1] == DIV) {
            e[i+2] = ops[e[i+1]](e[i], e[i+2]);
            e[i+1] = ADD;
            e[i] = 0;
        }
    }

    for (int i = 0; i < len - 2; i += 2) {
        e[i+2] = ops[e[i+1]](e[i], e[i+2]);
    }

    return len ? e[len-1] : 0;
}

int main() {
    int lens[] = {3, 3, 5, 5, 9, 11, 11};
    int exprs[][13] = {
        {2, MUL, 5},
        {2, ADD, 5},
        {2, MUL, 5, ADD, 3},
        {2, SUB, 5, MUL, 3},
        {2, ADD, 5, MUL, 3, MUL, 2, SUB, 3},
        {20, DIV, 5, ADD, 3, MUL, 2, SUB, 3, MUL, 4},
        {20, SUB, 5, SUB, 3, SUB, 4, MUL, 2, SUB, 3, MUL, 4},
    };
    
    for (int i = 0; i < 7; i++) {
        for (int j = 0; j < lens[i]; j++) {
            if (j % 2) {
                printf("%c", "+-*/"[exprs[i][j]]);
            }
            else {
                printf("%d", exprs[i][j]);
            }
        }
    
        printf("=%d\n", eval_math_expr_without_parens(lens[i], exprs[i]));
    }

    return 0;
}

快速测试：

$ ./a.out
2*5=10
2+5=7
2*5+3=13
2-5*3=-13
2+5*3*2-3=29
20/5+3*2-3*4=-2
20-5-3-4*2-3=1
$ ./a.out | awk -F '=' '{print $1}' | bc
10
7
13
-13
29
-2
1

如果您确实需要支持括号，那么您对树的深度是任意的，这种策略将无济于事。当然，这是一个已解决的问题，因此请查看 shunting yard algorithm 或将 bc 作为子进程运行并捕获结果（缓慢但容易）。