c语言计算器的一些错误

Question

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

#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10
 
typedef struct{       
    int data[STACK_INIT_SIZE];
    int Top;
    int Base;
    int sizeOfElement;
    int sizeOfStack;
}StackData;
 
typedef struct{     
    char symbol[STACK_INIT_SIZE];
    int Top;
    int Base;
    int sizeOfElement;
    int sizeOfStack;
}StackSymbol;

typedef enum{
    ERROR=0,
    OK=1
}Status;

Status StackData_Init(StackData* pStackData);                   
Status StackSymbol_Init(StackSymbol* pStackSymbol);       
bool StackData_IsEmpty(StackData* pStackData);
bool StackSymbol_IsEmpty(StackSymbol* pStackSymbol);
bool StackData_IsFull(StackData* pStackData);
bool StackSymbol_IsFull(StackSymbol* pStackSymbol);
void StackData_Push(StackData* pStackData,int num);            
void StackSymbol_Push(StackSymbol* pStackSymbol,char fuhao); 
int StackData_GetTop(StackData* pStackData);                     
char StackSymbol_GetTop(StackSymbol* pStackSymbol);           
int StackData_Pop(StackData* pStackData);                  
char StackSymbol_Pop(StackSymbol* pStackSymbol);
void StackData_Free(StackData* pStackData);
void StackSymbol_Free(StackSymbol* pStackSymbol);
void StackData_Clear(StackData* pStackData);
void StackSymbol_Clear(StackSymbol* pStackSymbol);            
float ConvertToFloat(char m[100]);                   
int Judge(char x);                                     
int Culculate(int x1,int x2,char s);
                   
Status StackData_Init(StackData* pStackData){
    pStackData->Top=-1;
    return OK;
}
 
Status StackSymbol_Init(StackSymbol* pStackSymbol){
    pStackSymbol->Top=-1;
    return OK;
}

bool StackData_IsEmpty(StackData* pStackData){
    if(pStackData->Top==pStackData->Base){
        return true;
    }
    else{
        return false;
    }
}

bool StackSymbol_IsEmpty(StackSymbol* pStackSymbol){
    if(pStackSymbol->Top==pStackSymbol->Base){
        return true;
    }
    else{
        return false;
    }
}

bool StackData_IsFull(StackData* pStackData){
    if(pStackData->Top-pStackData->Base==pStackData->sizeOfStack){
        return true;
    }
    else{
        return false;
    }
}

bool StackSymbol_IsFull(StackSymbol* pStacksymbol){
    if(pStacksymbol->Top-pStacksymbol->Base==pStacksymbol->sizeOfStack){
        return true;
    }
    else{
        return false;
    }
}
 
void StackData_Push(StackData* pStackData,int num){
    pStackData->Top++;
    pStackData->data[pStackData->Top]=num; 
}
 
void StackSymbol_Push(StackSymbol* pStackSymbol,char fuhao){
    pStackSymbol->Top++;
    pStackSymbol->symbol[pStackSymbol->Top]=fuhao;
}
 
int StackData_GetTop(StackData* pStackData){
    return pStackData->data[pStackData->Top];
}
 
char StackSymbol_GetTop    (StackSymbol* pStackSymbol){
    return pStackSymbol->symbol[pStackSymbol->Top];
}
 
int StackData_Pop(StackData* pStackData){
    int i;
    i=pStackData->data[pStackData->Top];
    pStackData->Top--;
    return i; 
}
 
char StackSymbol_Pop(StackSymbol* pStackSymbol){
    char a;
    a=pStackSymbol->symbol[pStackSymbol->Top];
    pStackSymbol->Top--;
    return a;
}

void StackData_Free(StackData* pStackData){
    free(pStackData->Base);
    pStackData->Base=NULL;
    return;
}

void StackSymbol_Free(StackSymbol* pStackSymbol){
    free(pStackSymbol->Base);
    pStackSymbol->Base=NULL;
    return;
}

void StackData_Clear(StackData* pStackData){
    pStackData->Top=pStackData->Base;
    return;
}

void StackSymbol_Clear(StackSymbol* pStackSymbol){
    pStackSymbol->Top=pStackSymbol->Base;
    return;
}

float ConvertToFloat(char m[100]){
    int i=0;
    float value=0;
    while(m[i]!='\0'&&m[i]!='.'){
        value=value*10+(m[i]-'0');
        i=i+1;
    }
    if(m[i]=='\0'){
        return value;
    }
    i=i+1;
    float weight=0.1;
    while(m[i]!='\0'){
        value=value+(m[i]-'0')*weight;
        weight=weight/10;
        i=i+1;
    }
    return value;
}
 
int Judge(char x){
    if(x=='('){
        return 1; 
    }
    else if(x=='+'||x=='-'){
        return 2;
    }
    else if(x=='*'||x=='/'){
        return 3;
    }
    else if(x=='^'){
        return 4;
    }
    else if(x==')'){
        return 5;
    } 
}
 
int Culculate(int x1,int x2,char s){
    int result;
    switch(s){
        case '+':{
            result=x1+x2;
            break;
        }
        case '-':{
            result=x1-x2;
            break;
        }
        case '*':{
            result=x1*x2;
            break;
        }
        case '/':{
            result=x1/x2;
            break;
        }
        case '^':{
            result=pow(x1,x2);
            break;
        }
    }
    return result;
}
 
int main(){
    printf("Enter The Expression Including '+' '-' '*' '/' '(' ')' And Intengers\n");
    StackData *data=(StackData*)malloc(sizeof(StackData));            
    StackSymbol *symbol=(StackSymbol*)malloc(sizeof(StackSymbol));    
    StackData_Init(data);                                                   
    StackSymbol_Init(symbol);                                               
    int a=0,b=0,result=0,x1,x2;                                        
    char y;
    char s[100]={0};
    char *str=(char *)malloc(sizeof(char)*100);
    while((y=getchar())!='\n'){
        str[a]=y;
        a++;
    }
    str[a]='\0';
    for(a=0;str[a]!='\0';a++){
        if(a==0&&str[a]=='-'){                  
            s[b++]=str[a];
        }
        else if(str[a]=='('&&str[a+1]=='-'){   
            a++;
            s[b++]=str[a++];
            while(str[a]>='0'&&str[a]<='9'){
                s[b]=str[a];
                b++;
                a++;
            }
            StackData_Push(data,atoi(s));
            while(b>0){
                s[b]=0;
                b--;
            }
            if(str[a]!=')'){
                a--;
                StackSymbol_Push(symbol,'(');
            }
        }
        else if(str[a]>='0'&&str[a]<='9'){
            while(str[a]>='0'&&str[a]<='9'){
            s[b]=str[a];
            b++;
            a++;    
            }
            StackData_Push(data,atoi(s));
            while(b>0){
                s[b]=0;
                b--;
            }
            a--;
        }
        else{
            if(symbol->Top==-1){
                StackSymbol_Push(symbol,str[a]);
            }
            else if(Judge(str[a])==1){
                StackSymbol_Push(symbol,str[a]);
            }
            else if(Judge(str[a])==2){                     
                if(Judge(StackSymbol_GetTop(symbol))==1){             
                    StackSymbol_Push(symbol,str[a]);
                }
                else if(Judge(StackSymbol_GetTop(symbol))==2){       
                    while(symbol->Top>=0&&data->Top>=1){
                        x2=StackData_Pop(data);
                        x1=StackData_Pop(data);
                        result=Culculate(x1,x2,StackSymbol_Pop(symbol));
                        StackData_Push(data,result);
                    }
                    StackSymbol_Push(symbol,str[a]);
                } 
                else if(Judge(StackSymbol_GetTop(symbol))==3){       
                    while(symbol->Top>=0&&data->Top>=1){
                        x2=StackData_Pop(data);
                        x1=StackData_Pop(data);
                        result=Culculate(x1,x2,StackSymbol_Pop(symbol));
                        StackData_Push(data,result);
                    }
                    StackSymbol_Push(symbol,str[a]);
                }
                else if(Judge(StackSymbol_GetTop(symbol))==4){
                    while(symbol->Top>=0&&data->Top>=1){
                        x2=StackData_Pop(data);
                        x1=StackData_Pop(data);
                        result=Culculate(x1,x2,StackSymbol_Pop(symbol));
                        StackData_Push(data,result);
                    }
                    StackSymbol_Push(symbol,str[a]);
                }
            }
            else if(Judge(str[a])==3){                     
                if(Judge(StackSymbol_GetTop(symbol))==1){           
                    StackSymbol_Push(symbol,str[a]);
                }
                else if(Judge(StackSymbol_GetTop(symbol))==2){      
                    StackSymbol_Push(symbol,str[a]);
                }
                else if(Judge(StackSymbol_GetTop(symbol))==3){     
                    while(symbol->Top>=0&&data->Top>=1){
                        x2=StackData_Pop(data);
                        x1=StackData_Pop(data);
                        result=Culculate(x1,x2,StackSymbol_Pop(symbol));
                        StackData_Push(data,result);
                    }
                    StackSymbol_Push(symbol,str[a]);
                }
                else if(Judge(StackSymbol_GetTop(symbol))==4){
                    while(symbol->Top>=0&&data->Top>=1){
                        x2=StackData_Pop(data);
                        x1=StackData_Pop(data);
                        result=Culculate(x1,x2,StackSymbol_Pop(symbol));
                        StackData_Push(data,result);
                    }
                    StackSymbol_Push(symbol,str[a]);
                }
            }
            else if(Judge(str[a])==5){                    
                do{
                    x2=StackData_Pop(data);
                    x1=StackData_Pop(data);
                    result=Culculate(x1,x2,StackSymbol_Pop(symbol));
                    StackData_Push(data,result);
                }while(Judge(StackSymbol_GetTop(symbol))!=1);
                StackSymbol_Push(symbol,str[a]);
            }
        }
    }
    free(str);
    while(symbol->Top!=-1){
        x2=StackData_Pop(data);
        x1=StackData_Pop(data);
        result=Culculate(x1,x2,StackSymbol_Pop(symbol));
        StackData_Push(data,result);
    }
    printf("The Result Is %d\n",data->data[0]);
    printf("Thank You\n");
    return 0;
    
}

求改错

Answer 1

结构体中的Base是int类型，不需要free