基于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[100]={'\0'};
    char *pFormula=Formula;
    char In[20];

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

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

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

    while (*(pFormula+i) != '\0')
    {
        printf("%c", *(pFormula+i));
        i++;
    }
    printf("\n");
    if(Mflg == 1)
    {
        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=0; i<17; i++)
    {
        if(strcmp(pKey[i], pIn) == 0)
        {
            return i;
        }
    }
    return -1;
}


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

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 -1;
    }
    S->top=S->base;
    S->size=STACK_SIZE;
    return 0;
}

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

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

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

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 -1;
        }
        S->top=S->base+S->size;
        S->size+=APPEND_SIZE;
    }
    *(S->top)=Elem;
    S->top++;
    return 0;
}

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


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 != 0)
            {
                return (Numa/Numb);
            }
            else
            {
                printf("\nDivide by zero !\n");
            }
        }
        default :
            return 0;
    }
}

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

    struct SNode xTem,TemResult,Data,Crtem;

    char Temp[20]={'\0'},Cntem[2];
    char CpFormula[102];
    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] >= '0') && (CpFormula[i] <= '9'))||(CpFormula[i] == '.'))//当前为数字,或者.
        {
            Cntem[0]=CpFormula[i];
            Cntem[1]='\0';
            strcat(Temp, Cntem);
            if((CpFormula[i+1] == '+') || (CpFormula[i+1] == '-')|| (CpFormula[i+1] == '*')|| (CpFormula[i+1] == '/')
                    || (CpFormula[i+1] == '(')|| (CpFormula[i+1] == ')') || (CpFormula[i+1] == '#'))
            {
                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;
}