基于c的简易计算器二

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <math.h>
 #include <stdbool.h>
 #include <malloc.h>

 #define STACK_SIZE 100
 #define APPEND_SIZE 10

 struct SNode
 {
     double data;    //存放操作数或者计算结果
     char ch;       //存放运算符
 };
 struct Stack       //顺序栈，用于计算表达式
 {
     struct SNode *top;
     struct SNode *base;
     int size;
 };

 int InitStack(struct Stack *S);           //初始化栈
 int DestroyStack(struct Stack *S);        //销毁栈
 int ClearStack(struct Stack *S);          //清空栈
 int GetTop(struct Stack S, struct SNode *Elem);  //取出栈顶结点并返回节点值
 int Push(struct Stack *S, struct SNode Elem);    //入栈
 int Pop(struct Stack *S, struct SNode *Elem);    //出栈

 void OutPut(char *pFormula, double CurrentNum, int Mflg);//主循环格式输出
 int RtOpe(char **pKey, char *pIn);                   //判断操作符以及计算器功能
 double Cal(char *pFormula);                              //计算表达式
 int Check(char *pFormula);                               //检查表达式

 char Judge(struct SNode Popc, struct SNode Cr);//比较运算符优先级
 double Operate(double Numa, char Opr, double Numb);//计算a，b经过opr运算后的结果
 char *killzero(char *Str, double Result);//消除末尾的0

 int main(void)
 {
     char Formula[]={'\0'};
     char *pFormula=Formula;
     char In[];

     int M=,Mflg=;
     char *Key[]={"+","-","*","/","=","MC","MR","MS","M+","M-","CE","C","~","sqr","rec","(",")"};
     char **pKey=Key;
     double CurrentNum =;
     bool fg=false;

     OutPut(pFormula , CurrentNum, Mflg);
     while ()
     {
         scanf("%s", In);
         if(isdigit(In[]) != )//当前输入的是数字
         {
             CurrentNum=atof(In);
             if(false == fg)
             {
                 strcat(pFormula, In);
             }
             fg=false;
         }
         else                 //当前输入的是操作符
         {
             switch(RtOpe(pKey, In))//判断是什么操作符
             {
             case ://"+"   写入算式
                 {
                     strcat(pFormula, In);
                     fg=false;
                     break;
                 }
             case ://"-"   写入算式
                 {
                     strcat(pFormula, In);
                     fg=false;
                     break;
                 }
             case ://"*"   写入算式
                 {
                     strcat(pFormula, In);
                     fg=false;
                     break;
                 }
             case ://"/"   写入算式
                 {
                     strcat(pFormula, In);
                     fg=false;
                     break;
                 }
             case ://"="   计算算式的值
                 {
                     CurrentNum=Cal(pFormula);
                     fg=false;
                     break;
                 }
             case ://"MC"  清除存储器中的值
                 {
                     M=;
                     Mflg=;
                     fg=false;
                     break;
                 }
             case ://"MR"  显示存储器中的值
                 {
                     CurrentNum=M;
                     fg=false;
                     break;
                 }
             case ://"MS"  将当前的值存放到存储器中
                 {
                     M=CurrentNum;
                     Mflg=;
                     fg=true;
                     break;
                 }
             case ://"M+"  将当前值和存储器中的值相加并存储
                 {
                     M+=CurrentNum;
                     fg=false;
                     break;
                 }
             case ://"M-"  将存储器中的值减去当前值并存储
                 {
                     M-=CurrentNum;
                     fg=false;
                     break;
                 }
             case ://"CE" 清除显示的数字
                 {
                     CurrentNum=;
                     fg=false;
                     break;
                 }
             case ://"C"  归零，清除当前的计算
                 {
                     CurrentNum=;
                     Formula[]='\0';
                     fg=false;
                     break;
                 }
             case ://"~"改变当前值的正负
                 {
                     CurrentNum=-CurrentNum;
                     fg=false;
                     break;
                 }
             case ://"sqr"求当前值的平方根
                 {
                     if(CurrentNum >= )
                     {
                         CurrentNum=sqrt(CurrentNum);
                     }
                     else
                     {
                         printf("\nError Calculate !\n");
                     }
                     fg=false;
                     break;
                 }
             case ://"rec"求显示数字的1/x的值
                 {
                     if(CurrentNum != )
                     {
                         CurrentNum=/CurrentNum;
                     }
                     else
                     {
                         printf("\nError Calculate !\n");
                     }
                     fg=false;
                     break;
                 }
             case ://"("   写入算式
                 {
                     strcat(pFormula, In);
                     fg=false;
                     break;
                 }
             case ://")"   写入算式
                 {
                     strcat(pFormula, In);
                     fg=false;
                     break;
                 }
             default:printf("\nError input !\n");
                     fg=false;
                     break;
             }
         }
         OutPut(pFormula, CurrentNum, Mflg);
     }
     return ;
 }

 void OutPut(char *pFormula, double CurrentNum, int Mflg)//主循环格式输出
 {
     system("cls");
     int i=;
     char Str[];
     char *pStr=Str;
     double num=CurrentNum;
     if(num >= )
     {
         num=;
     }
     printf("\n");

     while (*(pFormula+i) != '\0')
     {
         printf("%c", *(pFormula+i));
         i++;
     }
     printf("\n");
     if(Mflg == )
     {
         printf("M");
     }
     printf("\t%s\n", killzero(pStr, num));
     printf("\nMC\tMR\tMS\tM+\tM-\tCE\tC\t~\tsqr\trec\t(\t)\ninput:");

 }

 int RtOpe(char **pKey, char *pIn)//判断输入的操作符或者功能
 {
     int i;
     for(i=; i<; i++)
     {
         if(strcmp(pKey[i], pIn) == )
         {
             return i;
         }
     }
     return -;
 }

 int Check(char *pFormula)//判断表达式是否合格
 {
     int i=;
     int flag=;
     while(*(pFormula+i) != '\0')
     {
         if((*(pFormula+i) >= '' && *(pFormula+i) <= '') || *(pFormula+i) == '+' || *(pFormula+i) == '-'
                 || *(pFormula+i) == '*' || *(pFormula+i) == '/' || *(pFormula+i) == '('
                 || *(pFormula+i) == ')' || *(pFormula+i) == '.')
         {
             if(*(pFormula+i) == '(')
             {
                 flag++;
             }
             else if(*(pFormula+i) == ')')
             {
                 flag--;
             }
         }
         else
         {
             printf("\nError formula !\n");
             return ;
         }
         i++;
     }
     if(flag != )
     {
         printf("\nthe number '(',')' is wrong !\n");
         return ;
     }
     else
     {
         return ;
     }
 }

 int InitStack(struct Stack *S)//初始化栈
 {
     S->base=(struct SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
     if(S->base == NULL)
     {
         printf("\nMemory allocation failure !\n");
         return -;
     }
     S->top=S->base;
     S->size=STACK_SIZE;
     return ;
 }

 int DestroyStack(struct Stack *S)//销毁栈
 {
     free(S->base);
     return ;
 }

 int ClearStack(struct Stack *S)//清除栈
 {
     S->top=S->base;
     return ;
 }

 int GetTop(struct Stack S, struct SNode *Elem)//取出栈顶结点并返回节点值
 {
     if(S.top == S.base)
     {
         printf("Stack is empty !");
         return -;
     }
     *Elem=*(S.top-);
     return ;
 }

 int Push(struct Stack *S, struct SNode Elem)//入栈
 {
     if(((S->top)-(S->base)) >= S->size)
     {
         S->base=(struct SNode *)realloc(S->base,(S->size+APPEND_SIZE)*sizeof(struct SNode));
         if(S->base == NULL)
         {
             printf("Memory allocation failure !");
             return -;
         }
         S->top=S->base+S->size;
         S->size+=APPEND_SIZE;
     }
     *(S->top)=Elem;
     S->top++;
     return ;
 }

 int Pop(struct Stack *S, struct SNode *Elem)//出栈
 {
     if(S->top == S->base)
     {
         printf("Stack is empty !");
         return -;
     }
     *Elem=*(S->top-);
     S->top--;
     return ;
 }

 double Operate(double Numa, char Opr, double Numb)//计算Numa，Numb经过Opr运算后的结果
 {
     switch(Opr)
     {
         case '+':
             return (Numa+Numb);
         case '-':
             return (Numa-Numb);
         case '*':
             return (Numa*Numb);
         case '/':
         {
             if(Numb != )
             {
                 return (Numa/Numb);
             }
             else
             {
                 printf("\nDivide by zero !\n");
             }
         }
         default :
             return ;
     }
 }

 char Judge(struct SNode Popc, struct SNode Cr)//比较操作符优先级
 {
     char c;
     int i,j;
     char Prior[][] =
     {
        {'>','>','<','<','<','>','>'},
        {'>','>','<','<','<','>','>'},
        {'>','>','>','>','<','>','>'},
        {'>','>','>','>','<','>','>'},
        {'<','<','<','<','<','=',' '},
        {'>','>','>','>',' ','>','>'},
        {'<','<','<','<','<',' ','='}
     };//  算符间的优先关系
     char Opt[]={'+','-','*','/','(',')','#'};
     for(i=;i<;i++)
     {
         if(Popc.ch == Opt[i])
             break;
     }
     for(j=;j<;j++)
     {
         if(Cr.ch == Opt[j])
             break;
     }
     c=Prior[i][j];
     return c;
 }

 char *killzero(char *Str, double Result)//消除末尾的0
 {
     int i;
     sprintf(Str,"%lf",Result);
     i=strlen(Str)-;
     while(i && (Str[i] == ''))
     {
         Str[i]='\0';
         i--;
     }
     if(Str[i] == '.')
         Str[i]='\0';
     return Str;
 }

 double Cal(char *pFormula)//计算表达式
 {
     struct Stack optr,opnd,*Poptr,*Popnd;
     Poptr = &optr;
     Popnd = &opnd;

     int i=,j=;
     struct SNode Numa,Numb,Opr,Outopr,tem,result;
     struct SNode *pNuma=&Numa;
     struct SNode *pNumb=&Numb;
     struct SNode *pOpr=&Opr;

     struct SNode *pOutopr=&Outopr;
     struct SNode *presult=&result;
     struct SNode *ptem=&tem;
     result.data=;

     struct SNode xTem,TemResult,Data,Crtem;

     char Temp[]={'\0'},Cntem[];
     char CpFormula[];
     xTem.ch='#';

     InitStack(Poptr); //运算符栈
     Push(Poptr, xTem);
     InitStack(Popnd); //数字栈
     Check(pFormula);

     while(*(pFormula+j) != '\0')
     {
         CpFormula[j]=*(pFormula+j);
         j++;
     }
     CpFormula[j]='\0';
     strcat(CpFormula, "#");
     printf("\n%s\n", CpFormula);

     while(CpFormula[i] != '\0')
     {
         if(((CpFormula[i] >= '') && (CpFormula[i] <= ''))||(CpFormula[i] == '.'))//当前为数字,或者.
         {
             Cntem[]=CpFormula[i];
             Cntem[]='\0';
             strcat(Temp, Cntem);
             if((CpFormula[i+] == '+') || (CpFormula[i+] == '-')|| (CpFormula[i+] == '*')|| (CpFormula[i+] == '/')
                     || (CpFormula[i+] == '(')|| (CpFormula[i+] == ')') || (CpFormula[i+] == '#'))
             {
                 Data.data=(double)atof(Temp);
                 Push(Popnd, Data);
                 //printf("\nPush opnd\n");
                 strcpy(Temp, "\0");
             }
             i++;
         }
         else //当前为操作符
         {
             Crtem.ch=CpFormula[i];
             GetTop(optr, ptem);
             switch (Judge(tem, Crtem))
             {
                case '<':   // 栈顶元素优先权低
                 {
                     Push(Poptr, Crtem);
                     //printf("\nPush optr\n");
                     i++;
                     break;
                 }
                case '=':   // 脱括号并接收下一字符
                 {
                     Pop(Poptr, pOutopr);
                     //printf("\nPop optr\n");
                     i++;
                     break;
                 }
                case '>':   // 退栈并将运算结果入栈
                 {
                     Pop(Poptr, pOpr);
                     Pop(Popnd, pNumb);
                     Pop(Popnd, pNuma);
                     TemResult.data=Operate(Numa.data, Opr.ch, Numb.data);
                     //printf("\n>  %.4f\n",y.data);

                     Push(Popnd, TemResult);
                     break;
                 }
                default:
                 {
                     printf("\nError !\n");
                     break;
                 }
             }
         }
     }

     Pop(Popnd, presult);
     DestroyStack(Poptr);
     DestroyStack(Popnd);
     //printf("\n%.4f\n",result.data);*/
     return result.data;
 }