用c 写一个可以小数运算，带优先级的四则运算计算器，需要用到栈

好的，下面是一个简单的实现：

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

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

// 定义栈结构体
typedef struct {
    double *items;
    int top;
    int size;
} Stack;

// 初始化栈
void initStack(Stack *s, int size) {
    s->items = (double *) malloc(sizeof(double) * size);
    s->top = -1;
    s->size = size;
}

// 判断栈是否为空
int isEmpty(Stack *s) {
    return s->top == -1;
}

// 判断栈是否已满
int isFull(Stack *s) {
    return s->top == s->size - 1;
}

// 入栈操作
void push(Stack *s, double item) {
    if (isFull(s)) {
        printf("Stack Overflow\n");
        exit(1);
    }
    s->top++;
    s->items[s->top] = item;
}

// 出栈操作
double pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack Underflow\n");
        exit(1);
    }
    return s->items[s->top--];
}

// 获取栈顶元素
double peek(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack Underflow\n");
        exit(1);
    }
    return s->items[s->top];
}

// 判断运算符优先级大小
int precedence(char op) {
    switch (op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return -1;
    }
}

// 计算表达式的值
double evaluate(char *expr) {
    Stack numStack, opStack;
    initStack(&numStack, MAX_EXPR_LEN);
    initStack(&opStack, MAX_EXPR_LEN);

    int i = 0;
    while (expr[i] != '\0') {
        if (isdigit(expr[i])) {
            // 如果是数字，将其转换为 double 类型并入数字栈
            char *endPtr;
            double num = strtod(&expr[i], &endPtr);
            push(&numStack, num);
            i = endPtr - expr;
        } else if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || expr[i] == '/') {
            // 如果是运算符，将其与运算符栈栈顶元素比较优先级
            while (!isEmpty(&opStack) && precedence(peek(&opStack)) >= precedence(expr[i])) {
                double num2 = pop(&numStack);
                double num1 = pop(&numStack);
                char op = pop(&opStack);
                switch (op) {
                    case '+':
                        push(&numStack, num1 + num2);
                        break;
                    case '-':
                        push(&numStack, num1 - num2);
                        break;
                    case '*':
                        push(&numStack, num1 * num2);
                        break;
                    case '/':
                        push(&numStack, num1 / num2);
                        break;
                }
            }
            push(&opStack, expr[i]);
            i++;
        } else if (expr[i] == '(') {
            // 如果是左括号，入运算符栈
            push(&opStack, expr[i]);
            i++;
        } else if (expr[i] == ')') {
            // 如果是右括号，弹出运算符栈中的运算符进行计算，直到遇到左括号
            while (!isEmpty(&opStack) && peek(&opStack) != '(') {
                double num2 = pop(&numStack);
                double num1 = pop(&numStack);
                char op = pop(&opStack);
                switch (op) {
                    case '+':
                        push(&numStack, num1 + num2);
                        break;
                    case '-':
                        push(&numStack, num1 - num2);
                        break;
                    case '*':
                        push(&numStack, num1 * num2);
                        break;
                    case '/':
                        push(&numStack, num1 / num2);
                        break;
                }
            }
            if (!isEmpty(&opStack) && peek(&opStack) == '(') {
                pop(&opStack);
            } else {
                printf("Mismatched Parentheses\n");
                exit(1);
            }
            i++;
        } else {
            // 如果是非法字符，报错退出
            printf("Invalid Character\n");
            exit(1);
        }
    }

    // 将剩余的运算符依次弹出进行计算
    while (!isEmpty(&opStack)) {
        double num2 = pop(&numStack);
        double num1 = pop(&numStack);
        char op = pop(&opStack);
        switch (op) {
            case '+':
                push(&numStack, num1 + num2);
                break;
            case '-':
                push(&numStack, num1 - num2);
                break;
            case '*':
                push(&numStack, num1 * num2);
                break;
            case '/':
                push(&numStack, num1 / num2);
                break;
        }
    }

    // 返回最终结果
    return pop(&numStack);
}

int main() {
    char expr[MAX_EXPR_LEN];
    printf("Enter an expression: ");
    scanf("%s", expr);
    double result = evaluate(expr);
    printf("Result: %f\n", result);
    return 0;
}

这个计算器可以处理小数的四则运算，同时支持带括号的表达式。你可以输入类似 `1.23 + 4.56 * (7.89 - 0.12)` 这样的表达式进行计算。