写一个c++的中缀表达式转后缀表达式并且计算出结果的程序

为了让这个任务变得更具有挑战性，我将不会使用任何eval()函数来计算后缀表达式。而是手写一个算法，利用栈来计算后缀表达式。

具体思路如下：

1. 遍历中缀表达式的每一个字符。

2. 如果字符是一个数字，直接将其添加到后缀表达式中。

3. 如果字符是一个运算符，则将其加入到操作符栈中。

4. 如果字符是一个左括号，则将其加入到操作符栈中。

5. 如果字符是一个右括号，则将操作符栈中的所有操作符弹出并添加到后缀表达式中，直到找到左括号。将左括号从操作符栈中弹出。

6. 如果操作符栈内部有高优先级（乘除优先于加减）的操作符，将它们弹出并添加到后缀表达式中。

7. 重复1-6，直到处理完所有字符。

8. 将后缀表达式中的每一个字符依次弹出，如果是数字则加入到数字栈中，如果是操作符，则从数字栈中弹出两个数字进行计算，并将计算结果加入到数字栈中。最终数字栈中的唯一元素即为后缀表达式所代表的计算结果。

下面是c语言代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h> //isdigit函数头文件
#include <string.h> //strlen函数头文件

#define STACK_SIZE 100 //栈大小定义
char infix_exp[STACK_SIZE]; //中缀表达式字符串定义
char postfix_exp[STACK_SIZE]; //后缀表达式字符串定义

typedef struct
{
    char items[STACK_SIZE];
    int top;
} Stack;

Stack operator_stack = { .top = -1 }; //运算符栈定义
Stack value_stack = { .top = -1 }; //操作数栈定义

void push(Stack *s, char c)
{
    if (s->top >= STACK_SIZE - 1)
    {
        printf("Stack overflow.\n");
        exit(EXIT_FAILURE);
    }
    s->items[++(s->top)] = c;
}

char pop(Stack *s)
{
    if (s->top <= -1)
    {
        printf("Stack Underflow.\n");
        exit(EXIT_FAILURE);
    }
    return s->items[(s->top)--];
}

char peek(Stack *s)
{
    return s->items[s->top];
}

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

int priority(char op)
{
    switch (op)
    {
    case '+':
    case '-':
        return 1;
    case '*':
    case '/':
        return 2;
    default:
        return 0;
    }
}

void infix_to_postfix()
{
    int i;
    int k = 0; //后缀表达式字符串下标

    for (i = 0; infix_exp[i] != '\0'; i++)
    {
        if (isdigit(infix_exp[i])) //是数字，直接添加到后缀表达式中
        {
            postfix_exp[k++] = infix_exp[i];
        }
        else if (infix_exp[i] == '(') //左括号，直接入栈
        {
            push(&operator_stack, infix_exp[i]);
        }
        else if (infix_exp[i] == ')') //右括号，一直出栈直到找到左括号
        {
            while (!is_empty(&operator_stack) && peek(&operator_stack) != '(')
            {
                postfix_exp[k++] = pop(&operator_stack);
            }
            pop(&operator_stack); //将左括号弹出
        }
        else //操作符
        {
            while (!is_empty(&operator_stack) && priority(infix_exp[i]) <= priority(peek(&operator_stack)))
            {
                postfix_exp[k++] = pop(&operator_stack);
            }
            push(&operator_stack, infix_exp[i]);
        }
    }

    while (!is_empty(&operator_stack))
    {
        postfix_exp[k++] = pop(&operator_stack);
    }
    postfix_exp[k] = '\0';
}

void evaluate_postfix()
{
    int i, a, b;
    int len = strlen(postfix_exp);

    for (i = 0; i < len; i++)
    {
        if (isdigit(postfix_exp[i]))
        {
            push(&value_stack, postfix_exp[i] - '0'); //将字符转换成数字再添加到操作数栈中
        }
        else //遇到操作符，从操作数栈中弹出两个数进行计算
        {
            a = pop(&value_stack);
            b = pop(&value_stack);
            switch (postfix_exp[i])
            {
            case '+':
                push(&value_stack, b + a); //注意操作数入栈顺序
                break;
            case '-':
                push(&value_stack, b - a);
                break;
            case '*':
                push(&value_stack, b * a);
                break;
            case '/':
                push(&value_stack, b / a);
                break;
            }
        }
    }

    printf("The result is: %d\n", peek(&value_stack));
}

int main()
{
    printf("Please enter an infix expression: ");
    fgets(infix_exp, STACK_SIZE, stdin);
    infix_to_postfix();
    printf("The postfix expression is: %s\n", postfix_exp);
    evaluate_postfix();

    return 0;
}