发一个自己写的四则运算实现

 

    没什么新意（不仅仅处理个位数算吗？）啦，就是练练手，现在写代码的能里有所下降啊。呵呵 以后每天至少写一段代码，长度>=200吧。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
 //文件实现四则运算，主要原理1：后缀表达式 2：栈的使用
//步骤1，将中缀表达式转成后缀(因为这样就可以排除括号，后缀表达不需要括号)
//步骤2，根据后缀表达式计算结果

//优先级分为4级，分为栈内和栈外
//inp: */:3 +/-:2 (:1
//out: (:4 */:3 +/-:2 ):0


//a是栈顶符号，b是扫描到的符号
int compare(const char a,const char b)
{
    int la=0;int lb=0;
    //注意这里的a是已经在栈内的符号，所以(的优先级就变得最低了，此外不会遇到)因为遇到）的情况都会被处理掉的
    switch(a)
    {
        case '*':case '/':
            {
                la = 3;break;
            }
        case '+':case'-':
            {
                la = 2;break;
            }
        case'(':
            {
                la =1;break;
            }
        default:
            {
                printf("unknown symbol in the stack!\n");
                exit(-1);
            }
    }
    //b是所遇到的表达式里的符号，所以（的优先级最高，并且）的优先级最低，而且一定要处理到第一个匹配的（的位置
    switch(b)
    {
        case'(':
            {
                lb=4;break;
            }
        case '*':case'/':
            {
                lb=3;break;
            }
        case'+':case'-':
            {
                lb=2;break;
            }
        case')':
            {
                lb=0;break;
            }
        default:
            {
                printf("unknown symbol in the expretion!\n");
                exit(-1);
            }
    }
    return (la-lb);
}



//将前缀表达式转换为后缀表达式
char* trans2back(const char* mid)
{
    int len = strlen(mid);
    char* copy_mid = (char*)malloc((len+1)*sizeof(char));
    char* tmp = copy_mid;
    strcpy(tmp,mid);

    char* stack = (char*)malloc(len*sizeof(char));
    int top = -1;

    char* rt = (char*)malloc((len*2+1)*sizeof(char));
    char* back = rt;
    while(*tmp!='\0')
    {
        switch(*tmp)
        {
            //遇到符号的情况下(对于‘）’ )我们要特殊处理
            case'+':case'-':case'*':case'/':case'(':
                {
                    *back++=' ';//this is for the token between each number
                    if(top==-1)
                    {
                        stack[++top]=*tmp;
                    }
                    else
                    {
                        while(top>=0 && compare(stack[top],*tmp)>=0)
                        {
                            *back++=stack[top];
                            
                            top--;
                        }
                        stack[++top]=*tmp;
                    }
                    break;
                }
            case ')':
                {
                    while(top>=0 && stack[top]!='(')
                    {
                        *back++=stack[top--];
                    }
                    if(top<0)
                    {
                        printf("patten error!\n");
                        exit(-1);
                    }
                    top--;
                    break;
                }
            default:
                {
                    *back++=*tmp;
                    break;
                }
        }//end of switch
        tmp++;
    }//end of while
    //deal with the left operator
    if(top >= 0)
        while(top>=0)
        {
            *back++=stack[top--];
        }
    *back='\0';
    free(copy_mid);
    free(stack);
    return rt;
}

int isop(char a)
{
    if(a=='*'||a=='/'||a=='+'||a=='-')
        return 1;
    else
        return 0;
}

double op(double a,double b,char op)
{
    switch(op)
    {
        case'+':
            {
                return a+b;
            }
        case '-':
            {
                return a-b;
            }
        case '*':
            {
                return a*b;
            }
        case '/':
            {
                return a/b;
            }
        default:
            {
                printf("error int op()\n");
                exit(-1);
            }
    }
    printf("unknown op in op()\n");
    exit(-1);

}

double caculate(const char* back)
{
    double* stack = (double*)malloc(strlen(back)*sizeof(double));
    int top=-1;
    const char* p=back;
    const char* q=p;
    double result;
    while(*q!='\0')
    {
        if(isalnum(*q))
        {
            p=q;
            while(isalnum(*q))
            {
                q++;
            }
            stack[++top]=(double)atoi(p);
            //printf("add num %lf \n",stack[top]);
        }
        else if(*q == ' ')
            q++;
        else if(isop(*q))
        {
            //printf("the op is %c and the num is %lf and %lf\n",*q,stack[top],stack[top-1]);
            result = op(stack[top-1],stack[top],*q);
            stack[--top]=result;
            q++;
        }
    }
    free(stack);
    return result;
}





int main()
{
    char expression[100];
    while(1)
    {
        fgets(expression,100,stdin);
        expression[strlen(expression)-1]='\0';

        char* back = trans2back(expression);

        printf("the back expression is %s\n",back);

        printf("the result is %lf\n",caculate(back));

        free(back);
    }
    return 0;

}



    

现在老忘记事先保存要free掉的指针，然后再去free移动过的指针，所以老是出现一堆core dump...杯具。

另外，c貌似写这些代码的时候很不给力啊，栈实现，字符串处理什么的没有c++来的方便快捷。