C语言表达式计算器(页 1) - 网页编程 - 捌玖网络工作室 |网页制作|平面设计|建站交流|代码资料|建站教程|主机域名|asp、php、jsp代码|网站素材

zw2004 发表于 2008-1-21 17:17

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.c1Q8oW;Q#\
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)= }&Yi3H"Z5A&gD
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>D{'CS0{+wHo&u-~"E\(vx
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100JaE Swl/o9L
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};%WK\iC-{5@o

struct Stack{
SNode *top;
SNode *base;
int size;A jc'v {Z%O` F)G
};$~/`/S8| a4o

/*栈操作函数*/Qv'R!K+K
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/r`/m[{r;b%Z:H
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/ NEL{ ong
t)iAt5V(R\HL
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)&t'b+q+w&X0E2]j
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{%\&xy_7H7sy
      printf("动态分配内存失败!");
      return -1;
}JUa`Z\K]%}v
S.top=S.base;7m/V y,l3n/Jng
S.size=STACK_SIZE;1PJ1Me4Y c$`
return 0;
}
bl Y+P6J3Y0`0P
int DestroyStack(Stack &S){|9if@x2VM
{8TyfUg!\4u B#|!?G
free(S.base);/W$D+R1qdd
return 0;
}

int ClearStack(Stack &S)
{
S.top=S.base;
return 0;
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)
{wZ/SB-g0p(ex9[
      printf("栈以为空!");
      return -1;
}xN;B/QvQ;n
e=*(S.top-1);
return 0;)H*{,Q/}vh#ppS K
}
C4U*h0V&H
int Push(Stack &S,SNode e)3cy'wl"Z/kK
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));X&u]5E%tr
      if(S.base==NULL)$L GD3Ls/M)WM._'x
      {'PTqj5xF
         printf("动态分配内存失败!");-W j5H9FC P
         return -1;
      }
      S.top=S.base+S.size;4JjAT:X4m;]:u(o
      S.size+=APPEND_SIZE;
}r&aP3w5?L2d u
*S.top=e;
S.top++;$YSe-\5K
return 0;
}

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{o5Py7_ m9fr
      printf("栈为空!"); |6nE1QV7D
      return -1;_+L7|#?h5H.W-Ly
}v$K7W,GIR)Rc9n2H0o
e=*(S.top-1);\m5bR9u
S.top--;hP$zz\!};_4l%G
return 0;(lt7lYG/}y3zf;p$[
}
"t sV N6B
char get_precede(char s,char c)
{
switch(s)
{xA0d'j7y j]"D,oN
      case '+':                %vd^%Oyw
      case '-':#b$Y9q9_7d6G
         if(c=='+'||c=='-')U~Z%C:]b5wO"j
               return '>'; s[oLf@
         else if(c=='*'||c=='/')
               return '<';`7d+u@dp}
         else if(c=='(')
               return '<';_3r8Ty*@
         else if(c==')')
               return '>'; L.uA0R:H
         else
               return '>';w2{"pA2YO;O
      case '*':r&Ts E$Ziyh
      case '/':8HB]c3_w;Y8If3I
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')Lc;|e:yz{
               return '>';
         else if(c=='(')
               return '<';![sO\4B`9tc^
         else if(c==')')
               return '>'; [J$ce#^0fM~
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')0}I1s.e*Li2K
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')L`&k)^dL.| g
               return '=';
         elset1yZ ` P*z{
               return 'E';
      case ')':f(mGXK#^g
         if(c=='+'||c=='-')9n3N3]%lku-l5_ D
               return '>'; Ut:Rm9eu
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';hq3`n]
         else if(c==')')dvF2F3S4_![G&z
               return '>';L0l-l%q&de)hY1L
         elseAZ(k'RZ#lJ
               return '>';dK/yy3uZ
      case '#':fAr8OfI
         if(c=='+'||c=='-')
               return '<';8D^C1?$GR*]!O
         else if(c=='*'||c=='/')Y\A.A$tv$R q[
               return '<';cC sz{
         else if(c=='(') ^'n4L/qt%R0\|
               return '<';
         else if(c==')')Ddcku;i~$vV0k
               return 'E';b SI_\!^
         else
               return '=';bi(^q|Y|d(Sn b
      default:b!f9hBUe}f\3{
         break;FdT!\@+S])kc[1D
}
return 0;
}],n4Hy9b;iYW4P

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else K{E!OXQ
      return 1;
}i-WAq.]1jS x*f
L:`,Ady5c5B\
float operate(float x, char opr, float y))HQ4b+s*FbY;I!A_
{]U6C2R7H)cCg
float result;
switch (opr)
{d-nYK[,O
      case '+': r%O!Wm Y N4IH
         result = x + y;/pC9}q0Q;T4zN*~\
         break;T`AzemA
      case '-':
         result = x - y;
         break;
      case '*':
         result = x * y;
         break;/l(JHz}
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;
         }|Ux.xjvbP|!^:v
         else;}R_T-K7F p#VqB}
         {E2t)}Q:Dc l.^O|
               result = x / y;rN$ni0w
               break;
         }
   default: C;i@x Q4Nxk c4|B
         printf("Bad Input.\n");
         return 0;
}
return result;Rcz#J#[:mQA$E#L-K\
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;3Y*UQ Gqq2p
%P'ymhmow5In
InitStack(optr); /*用于寄存运算符*/4j `D+B P
InitStack(opnd); /*用于寄存操作数和计算结果*/#r:s(M,zg?
memset(buf,0,sizeof(buf));

printf("Enter your expression:");

opr_in.ch='#';eD5y3RKC2OPu
Push(optr,opr_in); /*'#'入栈*/Ugwx"Vi3Vg
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{F w2w8weI%cm&d
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {]M!B7fI;kZ~3|
         buf[i]=c;
         i++;
         c=getchar();
      }
      else /*是运算符*/
      {`-a K ])m ^l
         buf[i]='\0';4z2j)I;J#w0R3uf3p'o1K4o
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
         {UOO1ty i$H A2t
               opn_in.data=(float)atof(buf);
               Push(opnd,opn_in);
               printf("opnd入栈:[%f]\n",opn_in.data);
               i=0;W2m)EO `UqG9c(d
               memset(buf,0,sizeof(buf));f?)tM&Y~I{Y@\
         }
         opr_in.ch=c;j4B)n(qxA
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/se)xB+w+b
         {
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
                  Push(optr,opr_in);
                  printf("optr入栈:[%c]\n",opr_in.ch);/NBN&Tt%M0b
                  c=getchar();V0Y|9^k H
                  break;)h({i q9Y _F)|/t
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
                  Pop(optr,e);Q-oI ?]
                  printf("optr出栈:去掉括号\n");x7|bu+pd,W3OA
                  c=getchar();6aZ3@"Br*up
                  break;a-dBS-J'S:WZ
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/`!Q)k%QB3AD:J"o
                  Pop(optr,opr_t);Qr.M/j~-n W7sS
                  printf("optr出栈:[%c]\n",opr_t.ch);
                  if(Pop(opnd,b)<0)
                  {
                     printf("Bad Input!\n");1q"c XRU+I:D%r5O
                     fflush(stdin);:{6G9WOZ3OCS |+Cs"[
                     return -1;G Q!Dpt O5b
                  }
                  printf("opnd出栈:[%f]\n",b.data);(P'K2@/C'K1xao'Z!a
                  if(Pop(opnd,a)<0)Qdg1nmA
                  {
                     printf("Bad Input!\n");
                     fflush(stdin);s:mSmh\ JN!O
                     return -1;\3W(O8O6K }u
                  }1N&m:j9Z9^z
                  printf("opnd出栈:[%f]\n",a.data);
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/$\.u,XQ9} bR&I_
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/Q9VX:L/o
                  printf("结果入栈:[%f]\n",opn_tmp.data);
                  break;*BZ2`W2F)_'M2`)T}
         }^{6N$B[0~,K]
      }
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
}zn#rQB,}Z
GetTop(opnd,opn_tmp);U.bh8s"`X"r
DestroyStack(optr);
DestroyStack(opnd);j{K9d;z
return opn_tmp.data;
}

char *killzero(char *res,float result)p:b@*xI&Dy
{lZDEw%K.X%sD
int i;
i8tZjuq
sprintf(res,"%f",result);"wV(n#@saZ
i=(int)strlen(res)-1;H4}0o-a4e5D9J^
while(i&&res[i]=='0')
{IY{*F r$eHP,]
      res[i]='\0';
      i--;b]@wtpA$r
}-QOGi0~y(Ez D&Y!nk1?
if(res[i]=='.')!]?o!y'E;b
      res[i]='\0';r \7\4D rv*W I0q
return res;{@ [ [1w/M1S[
}

int main() k8BX rn-I
{
char ch;bH7Q2m;C_
char res[64];Vl.r7L4_s]8[!r
float result;
while(1)
{
      result=compute();
      printf("\nThe result is:%s\n",killzero(res,result));
      printf("Do you want to continue(y/n)?:") ;
      ch=getch();-]B![dhE,X2P,{0]0B8Q
      putchar(ch);
      if(ch=='n'||ch=='N')
         break;"`RHo/Nme
      else
         system("cls");)W*} QO"L2d5K"A
}
return 0;
}[/i][/i][/i][/i][/i][/i]0JB(@z*`z Y

[[i] 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 [/i]]

页: [1]

捌玖网络工作室's Archiver

C语言表达式计算器