如何实现应用通用栈的c语言计算器

在不使用链表的情况下使用通用栈实现中缀表达式转后缀表达式并计算，可计算带括号与浮点数的表达式，结果为负数依然可表达.

修改过后的:

你看上面例子那个可以吗?可以的话看一下那个代码:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<Windows.h>
#include<math.h>
 
#define max 100
#define Malloc(type) (type*)malloc(sizeof(type))
 
typedef struct stack
{
    double data[max];
    int top;
}stack;//字符栈
 
typedef struct stackd
{
    double data[max];
    int top;
}stackd;//数字栈
 
void calculator();//计算器
void push_stack(stack* p, char a);//入栈：运算符
void push_stackd(stackd* p, double a);//入栈：数字
double pop_stack(stack* p);//出栈：运算符
double pop_stackd(stackd* p);//入栈：数字
double cal(int* arr, int flag);//得到运算数（包括小数）
void destroy_stack(stack* s);//销毁栈
void destroy_stackd(stackd* s);//销毁栈(数字栈)
stack* init_stack();//初始化栈
stackd* init_stackd();//初始化栈(数字栈)
 
int main()
{
    calculator();
    return 0;
}
 
void calculator()
{
    char ch='#';
    int l = 0;
    while (1)
    {
        system("cls");
        int flag = 0;
        int flag2 = 0;
        int arr[max] = {0};
        double a;
        int f = 0;
        int m, k;
        double formed[max] = {0};
        char buf[max];
        int i = 0;
        double n1 = 0;
        double n2 = 0;
        double n3 = 0;
        stack* p = init_stack();
        stackd* pp = init_stackd();
        if (p)
        {
            scanf("%s", buf,max);
            int le = strlen(buf) + 1;
            for (i = 0; i < le; i++)
            {
                if (buf[i] >= '0' && buf[i] <= '9')
                {
                    arr[flag] = (buf[i] - '0');
                    flag++;
                    while ((buf[i + 1] >= '0' && buf[i + 1] < '9') || buf[i + 1] == '.')
                    {
                        if (buf[i + 1] >= '0' && buf[i + 1] < '9')
                        {
                            arr[flag] = buf[i + 1] - '0';
                        }
                        else if (buf[i + 1] == '.')
                        {
                            arr[flag] = buf[i + 1];
                        }
                        i++;
                        flag++;
                    }
                    formed[f] = cal(arr, flag);
                    f++;
                    flag = 0;
                }
                else if (buf[i] == '(')
                {
                    push_stack(p, buf[i]);
                }
                else if (buf[i] == ')')
                {
                    while ((a = pop_stack(p)) != '(' && p->top > 0)
                    {
                        formed[f] = (a + 0.00123);
                        f++;
                    }
                }
                else if (buf[i] == '+' || buf[i] == '-')
                {
                    while (1)
                    {
                        if (p->data[p->top - 1] != 40 && p->top > 0)
                        {
                            formed[f] = pop_stack(p) + 0.00123;
                            f++;
                        }
                        else
                            break;
                    }
                    push_stack(p, buf[i]);
                }
                else if (buf[i] == '*' || buf[i] == '/')
                {
                    while (1)
                    {
                        if (p->data[p->top - 1] != '+' && p->data[p->top - 1] != '-' && p->top > 0 && p->data[p->top - 1] != '(')
                        {
                            formed[f] = pop_stack(p) + 0.00123;
                            f++;
                        }
                        else
                            break;
                    }
                    push_stack(p, buf[i]);
                }
                else if (buf[i] == '^' )
                {
                    while (1)
                    {
                        if (p->data[p->top - 1] != '+' && p->data[p->top - 1] != '-' && p->top > 0 && p->data[p->top - 1] != '(' && p->data[p->top - 1] != '*' && p->data[p->top - 1] != '/')
                        {
                            formed[f] = pop_stack(p) + 0.00123;
                            f++;
                        }
                        else
                            break;
                    }
                    push_stack(p, buf[i]);
                }
                else if (buf[i] == ' ')
                    continue;
                else if (buf[i] == '\0')
                    continue;
            }
            while (p->top > 0)
            {
                formed[f] = pop_stack(p) + 0.00123;
                f++;
            }
        }
        for (i = 0; i < max - 1; i++)
        {
            if (formed[i] == '+' + 0.00123)
            {
                n1 = (double)pop_stackd(pp);
                n2 = (double)pop_stackd(pp);
                n3 = n1 + n2;
                push_stackd(pp, n3);
            }
            else if (formed[i] == '-' + 0.00123)
            {
                n1 = (double)pop_stackd(pp);
                n2 = (double)pop_stackd(pp);
                n3 = n2 - n1;
                push_stackd(pp, n3);
            }
            else if (formed[i] == '*' + 0.00123)
            {
                n1 = (double)pop_stackd(pp);
                n2 = (double)pop_stackd(pp);
                n3 = n2 * n1;
                push_stackd(pp, n3);
            }
            else if (formed[i] == '/' + 0.00123)
            {
                n1 = (double)pop_stackd(pp);
                n2 = (double)pop_stackd(pp);
                n3 = n2 / n1;
                push_stackd(pp, n3);
            }
            else if (formed[i] == '^' + 0.00123)
            {
                n1 = (double)pop_stackd(pp);
                n1 = n1 * n1;
                push_stackd(pp, n1);
            }
            else if (formed[i] == ' ' + 0.00123)
                continue;
            else if (formed[i] == '\0' + 0.00123)
                continue;
            else
            {
                push_stackd(pp, formed[i]);
            }
 
        }
        printf("%lf\n", pp->data[0]);
        printf("是否继续使用？回车以继续,q键退出：");
        destroy_stack(p);
        destroy_stackd(pp);
        getchar();
        ch = getchar();
        if (ch == '\n') continue;
        else if (ch == 'q') exit(0);
        system("pause");
    }
}
 
void push_stack(stack* p, char a)
{
    if (p->top < (max - 1))
    { 
 
        p->data[p->top] = a;
        p->top++;
    }
    else
        printf("进栈错误（d）\n");
}
 
double pop_stack(stack* p)
{
    if (p->top > 0)
    {
        p->top--;
        return p->data[p->top];
    }
    else
        printf("出栈错误\n");
}
 
void push_stackd(stackd* p, double a)
{
    if (p->top < (max - 1))
    {
 
        p->data[p->top] = a;
        p->top++;
    }
    else
        printf("进栈错误\n");
}
 
double pop_stackd(stackd* p)
{
    if (p->top > 0)
    {
        p->top--;
        return p->data[p->top];
    }
    else
        printf("出栈错误（d）\n");
}
 
stack* init_stack()
{
    stack* p;
    p = Malloc(stack);
    if (p)    p->top = 0;
    return p;
}
 
stackd* init_stackd()
{
    stackd* pp;
    pp = Malloc(stackd);
    if (pp) pp->top = 0;
    return pp;
}
 
void destroy_stack(stack* s)
{
    if (s)    free(s);
    s = NULL;
}
 
void destroy_stackd(stackd* s)
{
    if (s) free(s);
    s = NULL;
}
 
double cal(int* arr, int flag)
{
    double num = 0;
    int i = 0;
    int j = 0;
    for (i = 0; i < flag; i++)
    {
        if (arr[i] == '.')
            break;
    }
 
    for (j = 0; j < flag; j++)
    {
        if (arr[j] != '.')
            num = num + (arr[j] * pow(10, --i));
    }
    return num;
}

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

#define maxn 100005

char s[maxn],infixList[maxn][10];
char suffix[maxn][10];
int p=0;
char tmp[maxn];
int p1=0;

//把字符串根据操作数、运算符、括号拆开，存储到infixList数组中
int toInfixExpression(char *s) {
    int tot=0,n=strlen(s);
    for(int i=0;i<n;i++) {
        if(s[i]>='0'&&s[i]<='9') {
            int p=0;
            infixList[tot][p++]=s[i];
            while(i+1<n&&s[i+1]>='0'&&s[i+1]<='9') {
                infixList[tot][p++]=s[++i];
            }
            tot++;
        }else{
            infixList[tot++][0]=s[i];
        }
    }
    return tot;
}

//获得优先级
int getPriority(char c) {
    if(c=='+'||c=='-') return 1;
    else if(c=='*'||c=='/') return 2;
    else return 0; //处理'('的情况
}

//转换成后缀表达式
void parseSuffixExpression(char s[][10],int n) {

    for(int i=0;i<n;i++) {
        if(s[i][0]>='0'&&s[i][0]<='9') {
            strcpy(suffix[p++],s[i]);
        }else if(s[i][0]=='('){
            tmp[p1++]=s[i][0];
        }else if(s[i][0]==')') {
            while(tmp[p1-1]!='(') {
                suffix[p++][0]=tmp[--p1];
            }
            p1--;
        }else{
            while(p1!=0 && getPriority(tmp[p1-1])>=getPriority(s[i][0])){
                suffix[p++][0]=tmp[--p1];
            }
            tmp[p1++]=s[i][0];
        }
     }
     while(p1!=0) {
         suffix[p++][0]=tmp[--p1];
     }
}

//计算一个以字符串形式存储的数的值
int parseInt(char *s) {
    int k=strlen(s);
    int ans=0;
    for(int i=0;i<k;i++) {
        ans=ans*10+(s[i]-'0');
    }
    return ans;
}

//将数k转化成字符串形式存储到指针s开始的地方
void parseString(char *s,int k){
    char b[11];
    int point=0;
    do{
        b[point++]=(char)('0'+k%10);
        k/=10;
    }while(k!=0);
    for(int i=point-1,j=0;i>=0;i--,j++) {
        *(s+j)=b[i];
    }
    *(s+point)='\0';
}

//计算后缀表达式的值
int calculate() {
    int point=0;
    char t[maxn][10];
    int m=1;
    for(int i=0;i<p;i++) {
        int k=strlen(suffix[i]);
        if(suffix[i][0]>='0'&&suffix[i][0]<='9') {
            strcpy(t[point++],suffix[i]);
            t[point-1][k]='\0';
        }else {
            int b=parseInt(t[--point]);
            int a=parseInt(t[--point]);
            int res=0;
            if(suffix[i][0]=='+') {
                res=a+b;
                printf("(%d) %d + %d = %d\n",m++,a,b,res);
            }else if(suffix[i][0]=='-') {
                res=a-b;
                printf("(%d) %d - %d = %d\n",m++,a,b,res);
            }else if(suffix[i][0]=='*') {
                res=a*b;
                printf("(%d) %d * %d = %d\n",m++,a,b,res);
            }else if(suffix[i][0]=='/') {
                if(b==0) {
                    printf("除数为零出错！！！\n");
                    return -1;
                }
                res=a/b;
                printf("(%d) %d / %d = %d\n",m++,a,b,res);
            }
            parseString(t[point],res);
            point++;
        }
    }
    return parseInt(t[0]);
}

int main() {
    //输入字符串
    while(1) {
        p=p1=0;
        printf("------------------------------\n");
        printf("请输入待计算的表达式:");
        scanf("%s",s);
        int infixNum=toInfixExpression(s);
        parseSuffixExpression(infixList,infixNum);

        printf("运算过程如下所示：\n");
        int ans=calculate();
        printf("运算结果为: %d\n",ans);
        printf("------------------------------\n");
        printf("请选择是否继续(输入0表示退出,否则继续):");
        int opt;
        scanf("%d",&opt);
        if(opt==0) break;
        printf("\n");

    }
}

用栈实现简单的计算器（C语言版）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#define init 10
#define increase 5
//1.++，--输入时必须带括号 
//2.输入以#结尾
typedef struct SeqStack2//存运算字符的栈，后缀为2的均为字符的函数 
{
    char* pTop;
    char* pBase;
    int stacksize;
}SeqStack2;
typedef struct SeqStack1//存数字的栈，后缀为1的均为字符的函数 
{
    float* pTop;
    float* pBase;
    int stacksize;
}SeqStack1;
void InitStack1(SeqStack1& s)//初始化栈 
{
    s.pBase = (float*)malloc(sizeof(float) * init);
    if (s.pBase == NULL)exit(0);
    s.pTop = s.pBase;
    s.stacksize = init;
}
void InitStack2(SeqStack2& s)
{
    s.pBase = (char*)malloc(sizeof(char) * init);
    if (s.pBase == NULL)exit(0);
    s.pTop = s.pBase;
    s.stacksize = init;
}
void DestroyStack1(SeqStack1& s)//销毁栈 
{
    if (s.pBase != NULL)
    {
        free(s.pBase);
        s.pBase = NULL;
    }
    s.pTop = NULL;
    s.stacksize = 0;
}
void DestroyStack2(SeqStack2& s)
{
    if (s.pBase != NULL)
    {
        free(s.pBase);
        s.pBase = NULL;
    }
    s.pTop = NULL;
    s.stacksize = 0;
}
float GetTop1(SeqStack1 s)//获取栈顶元素值 
{
    if (s.pTop == s.pBase)
        return 0;
    return *(s.pTop - 1);
}
char GetTop2(SeqStack2 s)
{
    if (s.pTop == s.pBase)
        return 0;
    return *(s.pTop - 1);
}
void Push1(SeqStack1& s, float e)//入栈 
{
    if (s.pTop - s.pBase >= s.stacksize)
    {
        s.pBase = (float*)realloc(s.pBase, sizeof(float) * (s.stacksize + increase));
        if (s.pBase == NULL)
            exit(0);
        s.pTop = s.pBase + s.stacksize;
        s.stacksize += increase;
    }
    *s.pTop = e;
    s.pTop++;
}
void Push2(SeqStack2& s, char e)
{
    if (s.pTop - s.pBase >= s.stacksize)
    {
        s.pBase = (char*)realloc(s.pBase, sizeof(char) * (s.stacksize + increase));
        if (s.pBase == NULL)
            exit(0);
        s.pTop = s.pBase + s.stacksize;
        s.stacksize += increase;
    }
    *s.pTop = e;
    s.pTop++;
}
float Pop1(SeqStack1& s)//出栈 
{
    if (s.pTop == s.pBase)
        return 0;
    float e = *(s.pTop - 1);
    s.pTop--;
    return e;
}
char Pop2(SeqStack2& s)
{
    if (s.pTop == s.pBase)
        return 0;
    char e = *(s.pTop - 1);
    s.pTop--;
    return e;
}
bool isDidit(char a)//判断是否为数字 
{
    if (a >= '0' && a <= '9')
        return true;
    else
        return false;
}
char Compare(char c1, char c2)//比较符号的优先级 
{
    if (c1 == '+')
    {
        if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '#')
        {
            return 1;
        }
        else if (c2 == '*' || c2 == '/' || c2 == '(' || c2 == '%')
        {
            return 0;
        }
    }
    else if (c1 == '-')
    {
        if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '#')
        {
            return 1;
        }
        else if (c2 == '*' || c2 == '/' || c2 == '(' || c2 == '%')
        {
            return 0;
        }
    }
    else if (c1 == '*')
    {
        if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '*' || c2 == '/' || c2 == '#' || c2 == '%')
        {
            return 1;
        }
        else if (c2 == '(')
        {
            return 0;
        }
    }
    else if (c1 == '/')
    {
        if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '*' || c2 == '/' || c2 == '#' || c2 == '%')
        {
            return 1;
        }
        else if (c2 == '(')
        {
            return 0;
        }
    }
    else if (c1 == '%')
    {
        if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '*' || c2 == '/' || c2 == '#' || c2 == '%')
        {
            return 1;
        }
        else if (c2 == '(')
        {
            return 0;
        }
    }
    else if (c1 == '(')
    {
        if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/' || c2 == '(' || c2 == '%')
        {
            return 0;
        }
        else if (c2 == ')')
        {
            return 2;
        }
    }
    if (c1 == ')')
    {
        if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '*' || c2 == '/' || c2 == '#' || c2 == '%')
        {
            return 1;
        }
    }
    if (c1 == '#')
    {
        if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/' || c2 == '(' || c2 == '%')
        {
            return 0;
        }
        else if (c2 == '#')
        {
            return 2;
        }
    }
}
float Operate(float a, char b, float c)//运算函数 
{
    if (b == '+')
        return a + c;
    if (b == '-')
        return a - c;
    if (b == '*')
        return a * c;
    if (b == '/')
        return float(a) / float(c);
    if (b == '%' && a - int(a) > pow(10, -10) || c - int(c) > pow(10, -10))
    {
        printf("取模不是整数，错误！！");
        exit(0);
    }
    if (b == '%' && a - int(a) < pow(10, -10) && c - int(c) < pow(10, -10))
    {
        return int(a) % int(c);
    }
 
}
int main()
{
    SeqStack1 s1;
    SeqStack2 s2;
    InitStack1(s1);
    InitStack2(s2);
    Push2(s2, '#');
    int i = 0;
    char t = GetTop2(s2);
    char str1[150],str[150];
    double result;
    float data;
    gets(str1);
    printf("%s\n", str1);
    i = 0;
    float a, b;
    char theta;
    char ch;
    int flag=0;
    //将++，--转化为+1和-1,将负号转化为-1* 
    for (int num = 0;num < strlen(str1);num++)
    {
        if (str1[num] == '(' && str1[num + 1] == '+' && str1[num + 2] == '+' )
        {
            str[num + 1] = '1';
            str[num] = str1[num];
            str[num + 2] = str1[num + 2];
            num += 2;
        }
        else if (str1[num] == '(' && str1[num + 1] == '-' && str1[num + 2] == '-')
        {
            str[num] = '(';
            str[num + 1] = '-';
            str[num + 2] = '1';
            str[num + 3] = '+';
            for (int n = strlen(str1);n > num+3;n--)
            {
                str1[n] = str1[n - 1];
            }
            str1[num + 3] = '+';
            num += 3;
        }
        else if (str1[num] == '+' && str1[num + 1] == '+' && str1[num + 2] == ')' || str1[num] == '-' && str1[num + 1] == '-' && str1[num + 2] == ')')
        {
            str[num] = str1[num];
            str[num + 1] = '1';
            str[num + 2] = str1[num + 2];
            num += 2;
        }
        else if (str1[num] == '(' && str1[num + 1] == '-' && str1[num + 2] == '(')
        {
            str[num] = '(';
            str[num + 1] = '-';
            str[num + 2] = '1';
            str[num + 3] = '*';
            for (int n = strlen(str1)+1;n > num+3;n--)
            {
                str1[n] = str1[n - 2];
            }
            num += 3;
        }
        else if (num==0&&str1[num] == '-' && str1[num+1] == '(')
        {
            str[0] = '-';
            str[1] = '1';
            str[2] = '*';
            for (int n = strlen(str1)+1;n > num+2;n--)
            {
                str1[n] = str1[n - 2];
            }
            num += 2;
        }
        else
            str[num] = str1[num];
    }
    while (str[i - 1] != '#' || t != '#')
    {
        if (isDidit(str[i]))
        {
            float m, n = 0,p=0;
            while(str[i] >= '0' && str[i] <= '9'||str[i]=='.')//读入连续的数字 
            {
                if(str[i]=='.')
                {
                    flag=1;
                    i++;
                    continue;
                }
                if(flag!=0)
                {
                    p=pow(10,-flag)*int(str[i]-48);
                    n+=p;
                    flag++;
                    if(str[i+1]<'0'||str[i+1]>'9')
                    {
                        flag=0;
                    }
                    i++;
                    continue;
                }
                m = int(str[i] - 48);
                n = m + n * 10;
                i++;
            }
            data = float(n);
            Push1(s1, data);
 
        }
        else if (i == 0 && str[0] == '-')
        {
            float u,m,n=0;
            i++;
            while(str[i] >= '0' && str[i] <= '9')
            {
                m=float(str[i]-48);
                n = m + n * 10;
                i++;
            }
            u = float(n);
            Push1(s1, -u);
        }
        else if (str[i] == '(' && str[i + 1] == '-')
        {
            Push2(s2, str[i]);
            float u,m,n=0;
            i+=2;
            while(str[i] >= '0' && str[i] <= '9')
            {
                m=float(str[i]-48);
                n = m + n * 10;
                i++;
            }
            u = float(n);
            Push1(s1, -u);
        }
        //运算符操作 
        else
        {
            t = GetTop2(s2);
            ch = str[i];
            switch (Compare(t, ch))
            {
            case 0:
                Push2(s2, ch);
                i++;
                break;
            case 1:
                theta = Pop2(s2);
                a = Pop1(s1);
                b = Pop1(s1);
                Push1(s1, Operate(b, theta, a));
                break;
            case 2:
                theta = Pop2(s2);
                i++;
                break;
            default:
                break;
            }
        }
    }
    result = GetTop1(s1);
    printf("%f", result);
    DestroyStack1(s1);
    DestroyStack2(s2); 
    system("pause");
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAX_SIZE 21
#define ERROR 0
#define OK 1
typedef struct Num{
    int msg[MAX_SIZE];
    int top;
}numStack;
void initStack(numStack *num){
    num->top = 0;
}

int push(numStack *num,int e){
    if(num->top == MAX_SIZE)
        return ERROR;
    num->msg[num->top++] = e;
    return OK;
}
int pop(numStack *num,int *e){
    if(num->top == 0)
        return ERROR;
    *e = num->msg[--num->top];
    return OK;
}
int getTop(numStack *num,int *e){
    if(num->top == 0)
        return ERROR;
    *e = num->msg[num->top - 1];
    return OK;
}
int isEmpty(numStack *num){
    return num->top == 0;
}
typedef struct FU{
    char msg[MAX_SIZE];
    int top;
}fuStack;
void initFuStack(fuStack *fu){
    fu->top = 0;
}

int pushFu(fuStack *fu,char e){
    if(fu->top == MAX_SIZE)
        return ERROR;
    fu->msg[fu->top++] = e;
    return OK;
}
int popFu(fuStack *fu,char *e){
    if(fu->top == 0)
        return ERROR;
    *e = fu->msg[--fu->top];
    return OK;
}
int getFuTop(fuStack *fu,char *e){
    if(fu->top == 0)
        return ERROR;
    *e = fu->msg[fu->top - 1];
    return OK;
}
int isFuEmpty(fuStack *fu){
    return fu->top == 0;
}
int level(char ch){
    if(ch == '+' || ch == '-')
        return 1;
    else if(ch == '*' || ch == '/')
        return 2;
    else
        return 0;
}
int isNum(char ch){
    if(ch >= '0' && ch <= '9')
        return 1;
    return 0;
}
int yunsuan(char ch,numStack *num,int *result){
   int a,b;
   pop(num,&a);
   pop(num,&b);//将从栈中跳出两个元素，并将他们的值赋给a、b
   /*
   值得注意的是，必须是b - a，b / a，因为栈式先进后出的结构
   */
   switch(ch){
      case '+':
          *result = b + a;
           break;
      case '-':
          *result = b - a;
           break;
      case '*':
          *result = b * a;
           break;
      case '/':
          if(a == 0){
            return ERROR;//如果不符合运算法则，那么返回ERROR
          }
          *result = b / a;
          break;
   }
   return OK;
}
void getPreExpression(numStack *num,fuStack *fu,char *msg){
    int i,result,j,k = 0,a,b,count = 0;//count表示数字的个数
    char ch,tmp,arr[MAX_SIZE];//arr数组用于多位数字的拼接,ch表示当前的字符，tmp表示fuStack的栈顶元素
    for(i = 0; msg[i] != '\0'; i++){
        ch = msg[i];
        if(isNum(ch)){
            j = i;
            k = 0;//重置k
            //拼接数字
            while(isNum(msg[j])){
                arr[k++] = msg[j];
                j++;
            }
            arr[k] = '\0';//这一步十分重要
            /*
            这一步将i回到最后一个数字，因为在for循环中还会进行i++的操作，
            如果没有这一步，那么就会导致读取到的字符不全
            */
            i = j - 1;
            a = atoi(arr);//调用atoi方法，从而将这个多位数字的字符串转成整形数字
            count++;
            if(count == 1)
                printf("%d",a);//如果是第一个数字，那么前面不需要输出一个空格，否则要在前面输出空格
            else
                printf(" %d",a);
            push(num,a);//将数字压入栈中
        }else{
            //如果是运算符，那么需要分情况讨论
            if(isFuEmpty(fu) || ch == '('){
                //如果栈为空或者当前字符为左括号，直接将当前符号压入栈中
                pushFu(fu,ch);
            }else{
                /*
                如果栈不为空，那么需要讨论几种情况:
                ①栈顶是左括号，直接将当前字符压入栈中
                ②否则，如果当前符号是一个右括号，那么将从栈中跳出栈顶元
                素，并将其输出,同时将从numStack栈中跳出两个数字，进行相应
                的运算，之后将运算结果压入到numStack中,重复③的操作，直到
                栈顶符号式左括号，之后将左括号从fuStack中跳出
                ③否则，当前字符是普通字符，那么需要判断优先级。如果当前符
                号的优先级大于栈顶元素的优先级，那么直接入fu栈，否则从符栈
                中不断跳出栈顶元素，并将其输出，同时将从numStack中跳出两
                个数字，进行相应的运算，然后将运算结果压入到numStack中，
                重复此操作，直到当前符号的优先级大于栈顶符号的优先级，才将
                当前符号压入到fuStack中
                */
                getFuTop(fu,&tmp);
                if(tmp == '('){
                    //如果栈顶元素是一个左括号，那么直接入栈
                    pushFu(fu,ch);
                }else{
                  //当前的字符不是一个左括号，那么需要判断当前的符号是否为一个右括号
                  if(ch == ')'){
                    getFuTop(fu,&tmp);
                    while(tmp != '('){
                       popFu(fu,&tmp);
                       printf(" %c",tmp);
                       if(!yunsuan(tmp,num,&result)){
                          printf("被除数不可以为0，运算错误!!!\n");
                          return;
                       }
                       push(num,result);//如果运算符合运算法则，那么将运算结果压入到栈中
                       getFuTop(fu,&tmp);
                    }
                    popFu(fu,&tmp);
                  }else{
                     //当前的符号是一个普通符号，那么需要比较优先级
                     label:
                         if(isFuEmpty(fu) || level(ch) > level(tmp)){
                                //当前符号的优先级大于栈顶符号的优先级，那么直接入栈
                            pushFu(fu,ch);
                         }else{
                             //当前的符号的优先级小于等于栈顶符号的优先级，那么将栈顶元素从fu栈中跳出并输出
                            popFu(fu,&tmp);
                            printf(" %c",tmp); 
                            if(!yunsuan(tmp,num,&result)){
                                printf("被除数不可以为0，运算错误!!!\n");
                                return;
                            }
                            push(num,result);//如果运算符合运算法则，那么将运算结果压入到栈中
                            getFuTop(fu,&tmp);
                            goto label;//利用goto语句，从而实现当前的符号的优先级小于栈顶符号的优先级，然后将其压入
                         }
                  }
                }
            }

        }
    }
    //将num压入到fu栈中
    while(!isFuEmpty(fu)){
         popFu(fu,&tmp);
         printf(" %c",tmp);
         if(!yunsuan(tmp,num,&result)){
         //将进行相应的运算，然后将对应的运算结果赋值给result
            printf("被除数不可以为0，运算错误!!!\n");
            return;
         }
         push(num,result);//如果运算符合运算法则，那么将运算结果压入到栈中
    }
    printf("\n");
    pop(num,&a);//将num中的栈顶元素的值赋给a，并将其删除
    printf("%s的运算结果为%d\n",msg,a);
}
int main(){
    numStack *num = (numStack *)malloc(sizeof(numStack));
    fuStack *fu= (fuStack *)malloc(sizeof(fuStack));
    char msg[MAX_SIZE];
    initStack(num);//将栈进行初始化
    initFuStack(fu);
    scanf("%s",msg);//输入字符串
    getPreExpression(num,fu,msg);//将后缀表达式输出，同时将它的运算结果输出
    return 0;
}