c语言实现简单多位数带括号的计算器

下面是一个简单的多位数带括号的计算器的C语言实现，可以实现加、减、乘、除四则运算：

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

#define MAX_EXPR_LEN 100 // 表达式最大长度

typedef struct _stack {
    int top;
    int data[MAX_EXPR_LEN];
} Stack;

void initStack(Stack *s) {
    s->top = -1;
}

void push(Stack *s, int x) {
    if (s->top >= MAX_EXPR_LEN - 1) {
        printf("stack overflow\n");
        exit(1);
    }
    s->data[++(s->top)] = x;
}

int pop(Stack *s) {
    if (s->top < 0) {
        printf("stack underflow\n");
        exit(1);
    }
    return s->data[(s->top)--];
}

int isOperator(char c) {
    return (c == '+' || c == '-' || c == '*' || c == '/');
}

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

int calc(int a, int b, char op) {
    int res;
    switch (op) {
        case '+':
            res = a + b;
            break;
        case '-':
            res = a - b;
            break;
        case '*':
            res = a * b;
            break;
        case '/':
            if (b == 0) {
                printf("divide by zero\n");
                exit(1);
            }
            res = a / b;
            break;
        default:
            printf("invalid operator: %c\n", op);
            exit(1);
    }
    return res;
}

int eval(char *expr) {
    Stack numStack, opStack;
    initStack(&numStack);
    initStack(&opStack);

    int len = strlen(expr);
    int i = 0;
    while (i < len) {
        if (isdigit(expr[i])) {
            int num = 0;
            while (i < len && isdigit(expr[i])) {
                num = num * 10 + (expr[i] - '0');
                i++;
            }
            push(&numStack, num);
        } else if (expr[i] == '(') {
            push(&opStack, expr[i]);
            i++;
        } else if (expr[i] == ')') {
            while (opStack.top >= 0 && opStack.data[opStack.top] != '(') {
                char op = pop(&opStack);
                int b = pop(&numStack);
                int a = pop(&numStack);
                int res = calc(a, b, op);
                push(&numStack, res);
            }
            if (opStack.top < 0) {
                printf("mismatched parentheses\n");
                exit(1);
            }
            pop(&opStack);
            i++;
        } else if (isOperator(expr[i])) {
            while (opStack.top >= 0 && priority(opStack.data[opStack.top]) >= priority(expr[i])) {
                char op = pop(&opStack);
                int b = pop(&numStack);
                int a = pop(&numStack);
                int res = calc(a, b, op);
                push(&numStack, res);
            }
            push(&opStack, expr[i]);
            i++;
        } else {
            printf("invalid character: %c\n", expr[i]);
            exit(1);
        }
    }

    while (opStack.top >= 0) {
        char op = pop(&opStack);
        int b = pop(&numStack);
        int a = pop(&numStack);
        int res = calc(a, b, op);
        push(&numStack, res);
    }

    if (numStack.top != 0 || opStack.top != -1) {
        printf("invalid expression\n");
        exit(1);
    }

    return pop(&numStack);
}

int main() {
    char expr[MAX_EXPR_LEN];
    printf("请输入表达式：");
    fgets(expr, MAX_EXPR_LEN, stdin);
    expr[strlen(expr) - 1] = '\0';
    int res = eval(expr);
    printf("计算结果：%d\n", res);
    return 0;
}

这个计算器实现了一个简单的表达式求值算法，使用两个栈分别存储数字和操作符。当遇到数字时，将其压入数字栈中；当遇到左括号时，将其压入操作符栈中；当遇到右括号时，将操作符栈中的操作符一直弹出，直到遇到左括号，然后将左括号弹出；当遇到操作符时，将其与操作符栈中的操作符比较优先级，如果当前操作符优先级低于或等于栈顶操作符优先级，则先弹出栈顶操作符进行计算，直到当前操作符优先级高于栈顶操作符优先级，然后将当前操作符压入操作符栈中。最后，当表达式中的所有字符都处理完毕后，依次弹出操作符栈中的操作符进行计算，直到操作符栈为空，此时数字栈中只有一个元素，即为表达式的计算结果。