#include <stdio.h> #include <stdlib.h> #include <math.h> #include <conio.h> double deal_exp(char *exp) { } int main() { char expression[1024]; double result; printf("请输入一个算术表达式：（e退出）\n"); gets(expression); while(expression[0] != 'e') { result = deal_exp(expression); printf("%f\n", result); printf("请输入一个算术表达式：（e退出）\n"); gets(expression); } return 0; } 编写double deal_exp(char *exp)函数实现算术表达式的求值

这里提供一种基于栈的算法来实现算术表达式的求值。

具体实现步骤如下：

1. 定义一个栈来存储操作数和运算符，以及一个指针用来指向栈顶。

2. 遍历表达式中的每个字符，如果是数字则将其转换成实数并入栈；如果是运算符则将其与栈顶的运算符进行比较，如果优先级更高则入栈，否则弹出栈顶的运算符和两个操作数进行计算，并将结果入栈。

3. 最终栈中只剩下一个元素，即为表达式的计算结果。

下面是代码实现：

typedef struct {
    double num;     // 操作数
    char op;        // 运算符
} Element;

Element stack[1024];    // 栈
int top = -1;           // 栈顶指针

void push(Element e) {
    stack[++top] = e;
}

Element pop() {
    return stack[top--];
}

Element top_element() {
    return stack[top];
}

int is_empty() {
    return top == -1;
}

int is_operator(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;
    }
}

double calculate(double a, double b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
        default: return 0.0;
    }
}

double deal_exp(char *exp) {
    top = -1;
    int i = 0;
    while (exp[i] != '\0') {
        if (exp[i] == ' ') {
            i++;
            continue;
        }
        if (isdigit(exp[i])) {
            double num = 0.0;
            while (isdigit(exp[i])) {
                num = num * 10 + (exp[i] - '0');
                i++;
            }
            if (exp[i] == '.') {
                i++;
                double frac = 0.1;
                while (isdigit(exp[i])) {
                    num += frac * (exp[i] - '0');
                    frac /= 10;
                    i++;
                }
            }
            Element e = {num, '\0'};
            push(e);
        } else if (is_operator(exp[i])) {
            while (!is_empty() && priority(top_element().op) >= priority(exp[i])) {
                Element e2 = pop();
                Element e1 = pop();
                double res = calculate(e1.num, e2.num, e2.op);
                Element e = {res, '\0'};
                push(e);
            }
            Element e = {0.0, exp[i]};
            push(e);
            i++;
        } else {
            printf("表达式中含有非法字符！\n");
            return 0.0;
        }
    }
    while (!is_empty()) {
        Element e2 = pop();
        if (e2.op != '\0') {
            Element e1 = pop();
            double res = calculate(e1.num, e2.num, e2.op);
            Element e = {res, '\0'};
            push(e);
        } else {
            return e2.num;
        }
    }
    return 0.0;
}

注意，这里实现的算法只支持数字、四则运算和小数点，如果表达式中含有其他字符则会提示非法字符。同时，由于浮点数运算存在误差，可能会出现计算结果不精确的情况。