给我写一个代码，（1）利用栈将中缀表示转换为后缀表示，从键盘上输入一个中缀表达式（以=结束），将其转换为后缀表达式存入一个输出文件中（以=结束）。（2）应用后缀表示计算表达式的值：从一个输入文件中输入的后缀表达式（假设以=结束）的值，讲表达式的值在屏幕显示出来

为了实现这两个功能，我们可以分别创建两个函数，一个用于中缀到后缀的转换，另一个用于后缀表达式的求值。这里是一个简单的C语言示例：

首先，我们需要定义一个栈结构体，以及相应的操作：

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

typedef struct {
    char* stack;
    int top;
} Stack;

char pop(Stack* s);
void push(Stack* s, char c);
bool isOperator(char c);

// 中缀转后缀函数
char* infixToRPN(char* infix, char* rpn) {
    // 初始化
    Stack* s = (Stack*)malloc(sizeof(Stack));
    s->top = -1;
    strcpy(rpn, "");

    // 将中缀表达式扫描并处理
    int i = 0;
    while (infix[i] != '\0') {
        if (!isOperator(infix[i])) {  // 非运算符，直接添加到后缀
            rpn = strcat(rpn, infix + i);
        } else if (infix[i] == '(') {  // 左括号，压入栈
            push(s, '(');
        } else if (infix[i] == ')') {  // 右括号，弹出直到左括号
            while (s->stack[s->top] != '(') {
                rpn = strcat(rpn, pop(s));
            }
            s->top--;
        } else {  // 运算符，压入栈
            push(s, infix[i]);
        }
        i++;
    }

    // 弹出剩余的运算符
    while (s->top >= 0) {
        rpn = strcat(rpn, pop(s));
    }

    free(s->stack);
    s->stack = NULL;
    return rpn;
}

// 其他辅助函数
char pop(Stack* s) {
    if (s->top < 0) return '\0';
    char c = s->stack[s->top];
    s->top--;
    return c;
}

void push(Stack* s, char c) {
    s->stack[++s->top] = c;
}

bool isOperator(char c) {
    // 添加实际的操作符列表
    static const char operators[] = "+-*/";
    return strchr(operators, c) != NULL;
}

接下来，我们创建一个计算后缀表达式的值的函数：

double evaluateRPN(char* rpn) {
    Stack* s = (Stack*)malloc(sizeof(Stack));
    s->top = -1;

    for (int i = 0; rpn[i] != '\0'; i++) {
        if (isdigit(rpn[i])) {  // 整数，直接压栈
            double num = atof(&rpn[i]);
            push(s, (char)(num + '0'));
        } else {  // 运算符，弹出最近的两个数字进行运算
            double b = pop(s);
            double a = pop(s);
            switch (rpn[i]) {
                case '+':
                    push(s, (char)(a + b));
                    break;
                case '-':
                    push(s, (char)(a - b));
                    break;
                case '*':
                    push(s, (char)(a * b));
                    break;
                case '/':
                    push(s, (char)(a / b));
                    break;
                default:
                    printf("Invalid operator %c\n", rpn[i]);
                    return -1;  // 错误处理
            }
        }
    }

    double result = pop(s);
    free(s->stack);
    s->stack = NULL;
    return result;
}

现在你可以使用这两个函数来实现所需的功能：

int main() {
    char infix[100], rpn[100];
    FILE* input_file = fopen("input.txt", "r");
    FILE* output_file = fopen("output.txt", "w");

    // 输入中缀表达式
    fgets(infix, sizeof(infix), input_file);
    infix[strlen(infix) - 1] = '\0';  // 去掉换行符

    // 转换为后缀
    rpn = infixToRPN(infix, rpn);
    fprintf(output_file, "%s =", rpn);  // 写入输出文件

    fclose(input_file);
    
    // 计算后缀表达式并显示结果
    double value;
    fscanf(input_file, "= %lf", &value);  // 读取后缀表达式
    value = evaluateRPN(rpn);
    if (value != -1)
        printf("Value: %.2f\n", value);

    fclose(output_file);
    return 0;
}

记得替换`input.txt`和`output.txt`为实际文件名，这个程序会在输入文件中读取中缀表达式，转换后写入输出文件，并计算后缀表达式的值。