计算器C语言程序编写 基本要求： 1. 输入：不含变量的数学表达式的中缀形式，可以接受的操作符包括+、-、 *、/、%、(、)、√（选做）和 x y（选做）。 2. 输出：如果表达式正确，则输出表达式的结果，如果表达式非法，则输出 错误信息。 3. 选做：计算器的仿真界面。

好的，我可以为您提供一些关于计算器C语言程序编写的基本思路和代码示例。

首先，计算器程序主要涉及到中缀表达式的转换和计算。中缀表达式是我们平时使用的常见表达式，例如“3+4*5”，而计算机更适用于后缀表达式，也称为逆波兰表达式，例如“3 4 5 * +”。

因此，我们需要将输入的中缀表达式转换为后缀表达式，然后再进行计算。中缀表达式转后缀表达式的算法可以使用栈来实现。具体步骤如下：

1. 从左到右遍历中缀表达式的每个数字和符号。
2. 如果是数字，则直接输出。
3. 如果是符号，则判断其优先级与栈顶元素的优先级，如果栈顶元素优先级高，则将栈顶元素弹出并输出，直到栈顶元素优先级低于该符号或者栈为空，然后将该符号压入栈中。
4. 如果是左括号“（”，则直接将其压入栈中。
5. 如果是右括号“）”，则将栈顶元素弹出并输出，直到遇到左括号“（”，将左括号弹出但不输出。
6. 重复以上步骤，直到遍历完中缀表达式。

转换成后缀表达式后，我们可以使用栈来计算。具体步骤如下：

1. 从左到右遍历后缀表达式的每个数字和符号。
2. 如果是数字，则将其压入栈中。
3. 如果是符号，则从栈中弹出两个数字，并根据该符号进行计算，将计算结果压入栈中。
4. 重复以上步骤，直到遍历完后缀表达式。

下面是一个简单的计算器C语言程序示例，仅包含加减乘除和括号的计算：

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

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

typedef struct {
    double data[MAX_EXPR_LEN]; // 栈数据
    int top; // 栈顶指针
} Stack;

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

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

// 入栈
void push(Stack *stack, double num) {
    if (stack->top >= MAX_EXPR_LEN - 1) {
        printf("Stack overflow\n");
        exit(1);
    }
    stack->data[++stack->top] = num;
}

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

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

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

// 获取操作符优先级
int get_priority(char c) {
    if (c == '+' || c == '-') {
        return 1;
    } else if (c == '*' || c == '/') {
        return 2;
    } else {
        return 0;
    }
}

// 中缀表达式转后缀表达式
void infix_to_postfix(char *expr, char *postfix) {
    Stack stack;
    init(&stack);
    int i = 0, j = 0;
    while (expr[i] != '\0') {
        if (isdigit(expr[i])) { // 数字直接输出
            postfix[j++] = expr[i++];
            while (isdigit(expr[i])) {
                postfix[j++] = expr[i++];
            }
            postfix[j++] = ' ';
        } else if (is_operator(expr[i])) { // 操作符
            while (!is_empty(&stack) && is_operator(peek(&stack)) && get_priority(peek(&stack)) >= get_priority(expr[i])) {
                postfix[j++] = pop(&stack);
                postfix[j++] = ' ';
            }
            push(&stack, expr[i++]);
        } else if (expr[i] == '(') { // 左括号
            push(&stack, expr[i++]);
        } else if (expr[i] == ')') { // 右括号
            while (peek(&stack) != '(') {
                postfix[j++] = pop(&stack);
                postfix[j++] = ' ';
            }
            pop(&stack);
            i++;
        } else {
            i++;
        }
    }
    while (!is_empty(&stack)) { // 将栈中剩余的操作符输出
        postfix[j++] = pop(&stack);
        postfix[j++] = ' ';
    }
    postfix[j] = '\0'; // 字符串结尾符
}

// 计算后缀表达式
double evaluate_postfix(char *postfix) {
    Stack stack;
    init(&stack);
    int i = 0;
    while (postfix[i] != '\0') {
        if (isdigit(postfix[i])) { // 数字直接入栈
            double num = 0;
            while (isdigit(postfix[i])) {
                num = num * 10 + (postfix[i] - '0');
                i++;
            }
            push(&stack, num);
        } else if (is_operator(postfix[i])) { // 操作符
            double num2 = pop(&stack);
            double num1 = pop(&stack);
            switch (postfix[i]) {
                case '+': push(&stack, num1 + num2); break;
                case '-': push(&stack, num1 - num2); break;
                case '*': push(&stack, num1 * num2); break;
                case '/': push(&stack, num1 / num2); break;
            }
            i++;
        } else {
            i++;
        }
    }
    return pop(&stack); // 最终结果为栈中唯一元素
}

int main() {
    char expr[MAX_EXPR_LEN], postfix[MAX_EXPR_LEN];
    printf("Enter an expression:\n");
    fgets(expr, MAX_EXPR_LEN, stdin);
    infix_to_postfix(expr, postfix);
    printf("Postfix expression: %s\n", postfix);
    printf("Result: %f\n", evaluate_postfix(postfix));
    return 0;
}

该程序使用了两个栈，一个用于中缀表达式转后缀表达式，另一个用于计算后缀表达式。在计算过程中，使用了C语言中的标准库函数isdigit来判断字符是否为数字，可以通过判断ASCII码值来实现。

选做部分的仿真界面可以使用图形库或者控制台输出来实现，具体方法可以根据个人喜好进行选择。