c语言 算术表达式求值

C语言中的算术表达式求值是指将一个表达式中的变量和数字按照一定的运算符规则计算出结果的过程。在C语言中，算术表达式的运算顺序是由运算符的优先级和结合性来确定的，一般遵循先乘除后加减的规则，当然我们也可以使用括号来改变运算的优先级。

在C语言中，算术运算符包括加号+、减号-、乘号*、除号/和求模%等。除号/运算符可以整数除法或浮点数除法，当除数和被除数都是整数时，表示整数除法，结果只保留整数部分，当有一方为浮点数时，结果为浮点数除法。求余运算符%只能用于整数之间计算，它的作用是求出两个整数相除后余数。

当进行算术运算时，C语言会将表达式中的变量或数字转换成某种数据类型再进行计算。C语言中的数据类型包括整型(int)、浮点型(float/double)、字符型(char)和指针类型等，不同数据类型所能表示的范围和精度不一样，所以计算中要注意数据类型的匹配问题。

总之，C语言算术表达式求值需要注意运算符的优先级和结合性、数据类型的匹配问题，这样才能计算出符合预期的结果。

相关问题

使用递归函数编写C语言算术表达式求值程序

以下是使用递归函数编写C语言算术表达式求值程序的示例代码：

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

int get_value(char* expr);
int get_term(char* expr, int* index);
int get_factor(char* expr, int* index);

int main() {
    char expr[100];
    printf("Enter an arithmetic expression: ");
    scanf("%s", expr);
    int value = get_value(expr);
    printf("Result: %d\n", value);
    return 0;
}

// 递归函数求值
int get_value(char* expr) {
    int index = 0;
    int value = get_term(expr, &index);
    while (expr[index] != '\0') {
        char op = expr[index];
        if (op == '+') {
            index++;
            value += get_term(expr, &index);
        } else if (op == '-') {
            index++;
            value -= get_term(expr, &index);
        } else {
            printf("Invalid operator: %c\n", op);
            exit(1);
        }
    }
    return value;
}

// 获取项
int get_term(char* expr, int* index) {
    int value = get_factor(expr, index);
    while (expr[*index] != '\0') {
        char op = expr[*index];
        if (op == '*') {
            (*index)++;
            value *= get_factor(expr, index);
        } else if (op == '/') {
            (*index)++;
            int factor = get_factor(expr, index);
            if (factor == 0) {
                printf("Division by zero!\n");
                exit(1);
            }
            value /= factor;
        } else {
            break;
        }
    }
    return value;
}

// 获取因子
int get_factor(char* expr, int* index) {
    int value = 0;
    if (expr[*index] == '(') {
        (*index)++;
        value = get_value(expr);
        if (expr[*index] != ')') {
            printf("Missing closing parenthesis!\n");
            exit(1);
        }
        (*index)++;
    } else if (isdigit(expr[*index])) {
        while (isdigit(expr[*index])) {
            value = value * 10 + (expr[*index] - '0');
            (*index)++;
        }
    } else {
        printf("Invalid character: %c\n", expr[*index]);
        exit(1);
    }
    return value;
}

这个程序可以处理带有加减乘除运算符和括号的算术表达式。它使用了三个递归函数，分别用于求整个表达式的值、获取一个项的值和获取一个因子的值。其中，`get_value()` 函数调用 `get_term()` 函数来获取每个项的值，然后根据运算符进行加法或减法运算。`get_term()` 函数调用 `get_factor()` 函数来获取每个因子的值，然后根据运算符进行乘法或除法运算。`get_factor()` 函数根据当前字符是数字还是左括号，分别获取数字或者递归计算括号内的表达式的值。

c语言算术表达式求值。要求运行结果显示为“请输入一个算术表达式（e退出）”用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。 ​​​​​编写源程序中的 ​​​​d​​​​​​ouble deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果。

以下是一个简单的 C 语言算术表达式求值程序，实现了对输入的算术表达式的求值，支持负数、加减乘除和括号操作。

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

#define STACK_SIZE 100

// 定义操作符栈结构体
typedef struct {
    char op[STACK_SIZE];
    int top;
} OpStack;

// 定义操作数栈结构体
typedef struct {
    double val[STACK_SIZE];
    int top;
} ValStack;

// 操作符栈入栈函数
void op_push(OpStack *stack, char c) {
    if (stack->top >= STACK_SIZE) {
        printf("Error: op stack overflow!\n");
        exit(1);
    }
    stack->op[stack->top++] = c;
}

// 操作符栈出栈函数
char op_pop(OpStack *stack) {
    if (stack->top <= 0) {
        printf("Error: op stack underflow!\n");
        exit(1);
    }
    return stack->op[--stack->top];
}

// 操作数栈入栈函数
void val_push(ValStack *stack, double val) {
    if (stack->top >= STACK_SIZE) {
        printf("Error: val stack overflow!\n");
        exit(1);
    }
    stack->val[stack->top++] = val;
}

// 操作数栈出栈函数
double val_pop(ValStack *stack) {
    if (stack->top <= 0) {
        printf("Error: val stack underflow!\n");
        exit(1);
    }
    return stack->val[--stack->top];
}

// 获取操作符栈顶元素函数
char op_top(OpStack *stack) {
    if (stack->top <= 0) {
        printf("Error: op stack underflow!\n");
        exit(1);
    }
    return stack->op[stack->top - 1];
}

// 获取操作数栈顶元素函数
double val_top(ValStack *stack) {
    if (stack->top <= 0) {
        printf("Error: val stack underflow!\n");
        exit(1);
    }
    return stack->val[stack->top - 1];
}

// 判断是否为操作符函数
int is_op(char c) {
    return (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')');
}

// 判断操作符优先级函数
int op_precedence(char c) {
    switch (c) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

// 处理单个操作符函数
void deal_op(OpStack *op_stack, ValStack *val_stack) {
    char op = op_pop(op_stack);
    double val2 = val_pop(val_stack);
    double val1 = val_pop(val_stack);
    double res;
    switch (op) {
        case '+':
            res = val1 + val2;
            break;
        case '-':
            res = val1 - val2;
            break;
        case '*':
            res = val1 * val2;
            break;
        case '/':
            res = val1 / val2;
            break;
        default:
            printf("Error: invalid operator!\n");
            exit(1);
    }
    val_push(val_stack, res);
}

// 对算术表达式求值函数
double deal_exp(char *exp) {
    OpStack op_stack = {{0}, 0};
    ValStack val_stack = {{0}, 0};
    char *p = exp;
    while (*p) {
        if (isspace(*p)) {
            // 忽略空白字符
        } else if (isdigit(*p) || (*p == '-' && isdigit(*(p + 1)))) {
            // 处理数字
            char *q = p;
            while (isdigit(*q) || *q == '-') {
                q++;
            }
            double val = atof(p);
            val_push(&val_stack, val);
            p = q - 1;
        } else if (*p == '(') {
            // 处理左括号
            op_push(&op_stack, '(');
        } else if (*p == ')') {
            // 处理右括号
            while (op_top(&op_stack) != '(') {
                deal_op(&op_stack, &val_stack);
            }
            op_pop(&op_stack);
        } else {
            // 处理操作符
            while (op_precedence(*p) <= op_precedence(op_top(&op_stack))) {
                deal_op(&op_stack, &val_stack);
            }
            op_push(&op_stack, *p);
        }
        p++;
    }
    while (op_stack.top > 0) {
        deal_op(&op_stack, &val_stack);
    }
    return val_pop(&val_stack);
}

int main() {
    printf("请输入一个算术表达式（e退出）\n");
    char exp[STACK_SIZE];
    while (fgets(exp, STACK_SIZE, stdin)) {
        if (exp[0] == 'e') {
            break;
        }
        double res = deal_exp(exp);
        printf("%.2f\n", res);
        printf("请输入一个算术表达式（e退出）\n");
    }
    return 0;
}

注意，这个程序还有很多可以完善的地方，比如处理错误、增加更多的操作符等等。但是，以上代码已经可以满足题目要求。