用c语言写一个程序，输入一个由两个数据和一个运算符组成的表达式，根据运算符完成相应的运算，并输出结果

#include <stdio.h>

int main() {
    double num1, num2, result;
    char operator;

    printf("请输入表达式（格式：num1 operator num2）：");
    scanf("%lf %c %lf", &num1, &operator, &num2);

    switch (operator) {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num1 - num2;
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            result = num1 / num2;
            break;
        default:
            printf("运算符不合法！\n");
            return 0;
    }

    printf("结果：%lf\n", result);

    return 0;
}

相关问题

用C语言写一个 从键盘上输入一个四则运算的式子并输出计算结果

### 回答1：
首先，可以使用 scanf 函数从键盘输入一个字符串，然后使用栈来处理这个字符串并计算表达式的结果。

代码示例如下：

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

#define MAX_STACK_SIZE 100

// 定义栈结构体
typedef struct {
  double data[MAX_STACK_SIZE];
  int top;
} Stack;

// 初始化栈
void init_stack(Stack* stack) {
  stack->top = -1;
}

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

// 判断栈是否已满
int is_full(Stack* stack) {
  return stack->top == MAX_STACK_SIZE - 1;
}

// 入栈
void push(Stack* stack, double value) {
  if (is_full(stack)) {
    printf("Error: stack is full.\n");
    exit(1);
  }
  stack->data[++stack->top] = value;
}

// 出栈
double pop(Stack* stack) {
  if (is_empty(stack)) {
    printf("Error: stack is empty.\n");
    exit(1);
  }
  return stack->data[stack->top--];
}

// 获取栈顶元素
double peek(Stack* stack) {
  if (is_empty(stack)) {
    printf("Error: stack is empty.\n");
    exit(1);
  }
  return stack->data[stack->top];
}

int main(int argc, char* argv[]) {
  char expression[MAX_STACK_SIZE];  // 定义一个字符数组来存储表达式
  printf("Please enter an arithmetic expression: ");
  scanf("%s", expression);  // 从键盘输入表达式

  Stack operand_stack;  // 定义一个操作数栈
  init_stack(&operand_stack);  // 初始化操作数栈

  Stack operator_stack;  // 定义一个操作符栈
  init_stack(&operator_stack);  // 初始化操作符栈

  // 遍历表达式中的每个字  

### 回答2：
好的，以下是用C语言写的一个从键盘上输入一个四则运算的式子并输出计算结果的简单示例：

#include <stdio.h>

int main() {
float num1, num2, result;
char operator;

printf("请输入一个四则运算的式子（例如2 + 3）：");
scanf("%f %c %f", &num1, &operator, &num2);

switch(operator) {
case '+':
result = num1 + num2;
printf("结果为 %.2f\n", result);
break;
case '-':
result = num1 - num2;
printf("结果为 %.2f\n", result);
break;
case '*':
result = num1 * num2;
printf("结果为 %.2f\n", result);
break;
case '/':
if(num2 != 0) {
result = num1 / num2;
printf("结果为 %.2f\n", result);
} else {
printf("错误：除数不能为0\n");
}
break;
default:
printf("错误：无效的运算符\n");
break;
}

return 0;
}

这段代码首先提示用户输入一个四则运算的式子，然后使用`scanf`函数按照格式`%f %c %f`读取用户输入的两个数和一个运算符。接着使用`switch`语句判断运算符的类型，并根据相应的情况进行计算，最后输出结果。如果用户输入的是除法，还会进行除数为0的判断。

注意，以上示例代码假设用户输入的是两个浮点数，运算结果也会是浮点数，并且结果会被格式化为保留两位小数的形式进行输出。如果需要输入整数，可以将`%f`改为`%d`，相应地修改数据类型及格式化输出的部分即可。  

### 回答3：
使用C语言编写一个程序，实现从键盘上输入一个包含四则运算符的算术表达式，并输出计算结果。以下是一个简单的实现示例：

#include <stdio.h>

int main() {
float num1, num2, result;
char operator;

printf("请输入一个四则运算表达式（例如2+3）：");
scanf("%f%c%f", &num1, &operator, &num2);

switch (operator) {
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
if (num2 != 0) {
result = num1 / num2;
} else {
printf("除数不能为0。\n");
return 0;
}
break;
default:
printf("无效的运算符。\n");
return 0;
}

printf("计算结果为：%f\n", result);

return 0;
}

以上程序首先提示用户输入一个四则运算表达式，然后使用`scanf`函数按照指定格式读取输入的操作数和运算符。接着，使用`switch`语句根据运算符进行相应的计算操作，并将结果存储在`result`变量中。如果输入的运算符是无效的，会输出相应的错误提示信息。最后，程序输出计算结果。

注意，以上示例假设输入的操作数为浮点型，如果需要支持整数型操作数，请将`float`替换为`int`。

用c语言写一个表达式求值的程序

### 回答1：
好的，我可以回答这个问题。以下是一个用 C 语言编写的表达式求值程序的示例代码：

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

#define STACK_SIZE 100

typedef struct {
    int top;
    int data[STACK_SIZE];
} Stack;

void push(Stack *stack, int value) {
    if (stack->top == STACK_SIZE - 1) {
        fprintf(stderr, "Stack overflow\n");
        exit(1);
    }
    stack->data[++stack->top] = value;
}

int pop(Stack *stack) {
    if (stack->top == -1) {
        fprintf(stderr, "Stack underflow\n");
        exit(1);
    }
    return stack->data[stack->top--];
}

int evaluate(char *expr) {
    Stack stack = { .top = -1 };
    int i, op1, op2;
    char ch;

    for (i = ; expr[i] != '\'; i++) {
        ch = expr[i];
        if (ch >= '' && ch <= '9') {
            push(&stack, ch - '');
        } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
            op2 = pop(&stack);
            op1 = pop(&stack);
            switch (ch) {
                case '+': push(&stack, op1 + op2); break;
                case '-': push(&stack, op1 - op2); break;
                case '*': push(&stack, op1 * op2); break;
                case '/': push(&stack, op1 / op2); break;
            }
        }
    }

    return pop(&stack);
}

int main() {
    char expr[] = "23+4*";
    int result = evaluate(expr);
    printf("%d\n", result);
    return ;
}

这个程序可以计算后缀表达式的值，例如上面的表达式 "23+4*" 的值为 10。

### 回答2：
用C语言写一个表达式求值的程序可以借助栈来实现。下面是一种基本的实现方式：

首先，我们需要包含相关的头文件。如下所示：

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

#define MAX_SIZE 100

typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;

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

int is_empty(Stack* s) {
    return s->top == -1;
}

void push(Stack* s, int item) {
    if (s->top >= MAX_SIZE - 1) {
        printf("Stack overflow!\n");
        return;
    }
    s->data[++s->top] = item;
}

int pop(Stack* s) {
    if (is_empty(s)) {
        printf("Stack is empty!\n");
        exit(1);
    }
    return s->data[s->top--];
}

int get_top(Stack* s) {
    if (is_empty(s)) {
        printf("Stack is empty!\n");
        exit(1);
    }
    return s->data[s->top];
}

int calculate(int operand1, int operand2, char operator) {
    switch (operator) {
        case '+':
            return operand1 + operand2;
        case '-':
            return operand1 - operand2;
        case '*':
            return operand1 * operand2;
        case '/':
            return operand1 / operand2;
        default:
            printf("Invalid operator!\n");
            exit(1);
    }
}

int evaluate_expression(char* expression) {
    Stack operand_stack;
    Stack operator_stack;
    
    init_stack(&operand_stack);
    init_stack(&operator_stack);
    
    int i = 0;
    
    while (expression[i] != '\0') {
        if (expression[i] >= '0' && expression[i] <= '9') {
            int operand = 0;
            while (expression[i] >= '0' && expression[i] <= '9') {
                operand = operand * 10 + (expression[i] - '0');
                i++;
            }
            push(&operand_stack, operand);
        } else if (expression[i] == '+' || expression[i] == '-' || expression[i] == '*' || expression[i] == '/') {
            while (!is_empty(&operator_stack) && get_top(&operator_stack) != '(' && ((expression[i] != '*' && expression[i] != '/') || (get_top(&operator_stack) != '+' && get_top(&operator_stack) != '-'))) {
                int operand2 = pop(&operand_stack);
                int operand1 = pop(&operand_stack);
                char operator = pop(&operator_stack);
                int result = calculate(operand1, operand2, operator);
                push(&operand_stack, result);
            }
            push(&operator_stack, expression[i]);
            i++;
        } else if (expression[i] == '(') {
            push(&operator_stack, expression[i]);
            i++;
        } else if (expression[i] == ')') {
            while (!is_empty(&operator_stack) && get_top(&operator_stack) != '(') {
                int operand2 = pop(&operand_stack);
                int operand1 = pop(&operand_stack);
                char operator = pop(&operator_stack);
                int result = calculate(operand1, operand2, operator);
                push(&operand_stack, result);
            }
            if (!is_empty(&operator_stack) && get_top(&operator_stack) == '(') {
                pop(&operator_stack); // 弹出左括号
            } else {
                printf("Invalid expression!\n");
                exit(1);
            }
            i++;
        } else {
            printf("Invalid expression!\n");
            exit(1);
        }
    }
    
    while (!is_empty(&operator_stack)) {
        int operand2 = pop(&operand_stack);
        int operand1 = pop(&operand_stack);
        char operator = pop(&operator_stack);
        int result = calculate(operand1, operand2, operator);
        push(&operand_stack, result);
    }
    
    return pop(&operand_stack);
}

int main() {
    char expression[100];
    printf("请输入表达式：");
    scanf("%s", expression);
    
    int result = evaluate_expression(expression);
    printf("结果为：%d\n", result);
    
    return 0;
}

以上是一个简单的表达式求值程序的实现。通过输入一个中缀表达式，程序会自动计算并给出结果。同时，该程序还可以处理括号、加减乘除运算等情况，并能够处理多位数的操作数。

### 回答3：
使用C语言编写一个表达式求值的程序可以通过递归和栈来实现。

首先，定义一个结构体，用来表示表达式中的操作数和运算符：

struct Node {
    int value;       // 操作数或运算结果的值
    char operator;   // 运算符
    struct Node *left;    // 左子节点
    struct Node *right;   // 右子节点
};

然后，创建一个栈结构用来存储表达式中的操作数和运算符：

struct Stack {
    struct Node* data[100];
    int top;
};

接下来，定义一系列函数来实现表达式求值的操作，包括：

1. 创建一个新的节点：

struct Node* newNode(int value, char operator);

2. 检查一个字符是否为运算符：

int isOperator(char c);

3. 将一个字符转换为整数：

int charToInt(char c);

4. 将中缀表达式转换为逆波兰表达式：

int infixToPostfix(char *infix, char *postfix);

5. 根据逆波兰表达式构建表达式树：

struct Node* buildExpressionTree(char *postfix, int length);

6. 计算表达式树的值：

int evaluateExpressionTree(struct Node* root);

最后，在主函数中，使用以上函数来完成表达式求值的过程：

int main() {
    char infix[100], postfix[100];
    printf("请输入中缀表达式：");
    scanf("%s", infix);
    int length = infixToPostfix(infix, postfix);
    struct Node* root = buildExpressionTree(postfix, length);
    int result = evaluateExpressionTree(root);
    printf("结果为：%d\n", result);
    return 0;
}

以上就是用C语言实现一个表达式求值的简单示例，可以根据实际需求进行进一步的扩展和优化。