c语言用菜单做计算器,小白求大神帮忙用C语言做个多功能计算器！！！！

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

请自己把所有[全角空格'　']换成两个正常空格

#include

#include

#include

#define Reduce 0

#define Shift 1

#define Error 2

#define Accept 3

/* {"$eof","$start","expr","+","-","*","/","(",")"} */

typedef struct tr_s{int action,n;}tr_t;

typedef struct rule_s{int head,len;double(*callback)(double*);}rule_t;

typedef struct lex_s{int k;double v;}lex_t;

static tr_t CalcStates[32][9]={

{　　 {2,0},　　{2,0},　　{1,1},　　{1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {3,0},　　{2,0},　　{2,0},　　{1,5},　　{1,6},　　{1,7},　　{1,8},　　{2,0},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,9},　　{1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,10}, {1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,11}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,15}, {1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,16}, {1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,17}, {1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,18}, {1,2},　　{1,3},　　{2,0},　　{2,0},　　{1,4},　　{2,0}　　 },

{　　 {0,6},　　{2,0},　　{2,0},　　{0,6},　　{0,6},　　{0,6},　　{0,6},　　{2,0},　　{2,0}　　 },

{　　 {0,7},　　{2,0},　　{2,0},　　{0,7},　　{0,7},　　{0,7},　　{0,7},　　{2,0},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{1,19}, {1,20}, {1,21}, {1,22}, {2,0},　　{1,23}　　},

{　　 {2,0},　　{2,0},　　{1,24}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,25}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,26}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {0,2},　　{2,0},　　{2,0},　　{0,2},　　{0,2},　　{1,7},　　{1,8},　　{2,0},　　{2,0}　　 },

{　　 {0,3},　　{2,0},　　{2,0},　　{0,3},　　{0,3},　　{1,7},　　{1,8},　　{2,0},　　{2,0}　　 },

{　　 {0,4},　　{2,0},　　{2,0},　　{0,4},　　{0,4},　　{0,4},　　{0,4},　　{2,0},　　{2,0}　　 },

{　　 {0,5},　　{2,0},　　{2,0},　　{0,5},　　{0,5},　　{0,5},　　{0,5},　　{2,0},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,27}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,28}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,29}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {2,0},　　{2,0},　　{1,30}, {1,12}, {1,13}, {2,0},　　{2,0},　　{1,14}, {2,0}　　 },

{　　 {0,1},　　{2,0},　　{2,0},　　{0,1},　　{0,1},　　{0,1},　　{0,1},　　{2,0},　　{2,0}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{0,6},　　{0,6},　　{0,6},　　{0,6},　　{2,0},　　{0,6}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{0,7},　　{0,7},　　{0,7},　　{0,7},　　{2,0},　　{0,7}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{1,19}, {1,20}, {1,21}, {1,22}, {2,0},　　{1,31}　　},

{　　 {2,0},　　{2,0},　　{2,0},　　{0,2},　　{0,2},　　{1,21}, {1,22}, {2,0},　　{0,2}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{0,3},　　{0,3},　　{1,21}, {1,22}, {2,0},　　{0,3}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{0,4},　　{0,4},　　{0,4},　　{0,4},　　{2,0},　　{0,4}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{0,5},　　{0,5},　　{0,5},　　{0,5},　　{2,0},　　{0,5}　　 },

{　　 {2,0},　　{2,0},　　{2,0},　　{0,1},　　{0,1},　　{0,1},　　{0,1},　　{2,0},　　{0,1}　　 },

};

double callback_fin(double*val){return val[0];}

double callback_brk(double*val){return val[1];}

double callback_add(double*val){return val[0]+val[2];}

double callback_sub(double*val){return val[0]-val[2];}

double callback_mul(double*val){return val[0]*val[2];}

double callback_div(double*val){return val[0]/val[2];}

double callback_pos(double*val){return +val[1];}

double callback_neg(double*val){return -val[1];}

static rule_t CalcRules[]={

{1,1,callback_fin},

{2,3,callback_brk},

{2,3,callback_add},

{2,3,callback_sub},

{2,3,callback_mul},

{2,3,callback_div},

{2,2,callback_pos},

{2,2,callback_neg}

};

lex_t Calc_lex(const char**p){

int c;

lex_t temp;

temp.k=-1;

while((c=**p)){

switch(c){

case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':{

temp.k=2;

int n;

sscanf(*p,"%lf%n",&temp.v,&n);

*p=*p+n;

break;

}break;

case '+':++*p;temp.k=3;break;

case '-':++*p;temp.k=4;break;

case '*':++*p;temp.k=5;break;

case '/':++*p;temp.k=6;break;

case '(':++*p;temp.k=7;break;

case ')':++*p;temp.k=8;break;

default:++*p;// erase the character

}

if(temp.k!=-1)

return temp;

}

temp.k=0;

return temp;

}

int CalcErrorFlag;

void CalcStart(){

CalcErrorFlag=0;

}

double CalcOnError(){

CalcErrorFlag=1;

return 0;

}

double Calc(const char* s){

CalcStart();

void* smem=malloc(sizeof(int)*(strlen(s)+3));

void* vmem=malloc(sizeof(double)*(strlen(s)+1));

int* state=(int*)smem;*state=0;

double* value=(double*)vmem-1;

lex_t next;

int endloop=0;

int hasnext=0;

while(!endloop){

if(!hasnext){

next=Calc_lex(&s);

hasnext=1;

}

tr_t translate=CalcStates[*state][next.k];

switch(translate.action){

case Shift:

*++state=translate.n;

*++value=next.v;

hasnext=0;

break;

case Accept:

endloop=1;//no break

case Reduce:

state-=CalcRules[translate.n].len-1;

value-=CalcRules[translate.n].len-1;

*value=CalcRules[translate.n].callback(value);

*state=CalcStates[*(state-1)][CalcRules[translate.n].head].n;

break;

case Error:

free(smem);free(vmem);

return CalcOnError();// return NaN

}

}

double final=*value;

free(smem);free(vmem);

return final;

}

int main(){

printf("%f",Calc("1+-1"));

}