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

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

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=]GU+{r0j
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>nUn"I7]5L+x
#include <string.h>
#include <conio.h>
#include <malloc.h>Pz6];D0Rb/Z3j_
B$bN;OW/rT
#define STACK_SIZE 100
#define APPEND_SIZE 10
aL:^,OG"Xu zM
struct SNode{)Uq*fPv'S
float data; /*存放操作数或者计算结果*/|f(F6}M8M
char ch; /*存放运算符*/&jHV Ts.K!I"}
};
&rX/HI.C&k
struct Stack{
SNode *top;~V#}9DlW
SNode *base;8vfM}0NY*i`lK
int size;^)iZR3BrR/T1Cm
};u8a?V3R#_Y

/*栈操作函数*//B7D+E5Jp$l
int InitStack(Stack &S); /*创建栈*/N?*fR4e9t
int DestroyStack(Stack &S); /*销毁栈*/~P3~&U(n _Skd nJ
int ClearStack(Stack &S); /*清空栈*/7|,HHD[r
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/1J!FWgPo#_q6?s
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/z,`,yGA6E.`*Y)Er$Z?
GQ#YY {,n{N6Y
/*表达式计算器相关函数*/%Th#olp&ZJ/H
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计算后的结果*/jc"p/O ~#@(Qg;fNf
float compute(); /*表达式结算器主函数*/)V@5vb}
char *killzero(float result); /*去掉结果后面的0*/ 6n9Y5L5JmsE v%OJ

int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));&N.Q a:C?
if(S.base==NULL)
{
      printf("动态分配内存失败!");q4{/g[A S sMhB(d&H&z
      return -1;
}s'bV d0Xw;p j
S.top=S.base;
S.size=STACK_SIZE; i]w0G-U9M9]
return 0;
}

int DestroyStack(Stack &S)
{9g7Y~)U4@Tt
free(S.base);d0Va+K#@Z_oY
return 0;%c0q H\\b\m
}

int ClearStack(Stack &S)%T7p"{4K5_}*bh0n
{
S.top=S.base;/OoSNf2w f6b5o
return 0;c t p#^ks
}

int GetTop(Stack S,SNode &e)
{"W"}T)h o
if(S.top==S.base)Z0g\1\:~/K Nt
{
      printf("栈以为空!");
      return -1;
}7FY!KtOeQM
e=*(S.top-1);I_2bchYE
return 0;
}B0P4a-p8j]
?ZFKL@|
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{jV$n Q_H)^gF
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {cuRxg
         printf("动态分配内存失败!");
         return -1;
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;2h;`%H)H:?j^(DKpLO
}
*S.top=e;&?MUA7[a
S.top++;p%l:q e2e3XL6j"M
return 0;8M6V/tI$lU0]/e
}wX;kM,Q:i1O9A

int Pop(Stack &S,SNode &e)
{EOVJ#bz7\
if(S.top==S.base)b t4W/s"m*[)z,d7q&[
{)L2N*VF w
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);,d h l;I2ST5c
S.top--;
return 0;2CaDa1w1u*D
}_Uwv*u+\!c Q
"Mg lU\FP
char get_precede(char s,char c) lJX T9^1qZ~9~
{-jae%cb
switch(s)
{
      case '+':
      case '-':
         if(c=='+'||c=='-')1N \ M$fJ#sZw
               return '>';
         else if(c=='*'||c=='/')EvmLR,FVJ)t
               return '<';
         else if(c=='(')&^#y;c!Gzw
               return '<'; om[|zj
         else if(c==')')
               return '>';)V"X5b/XpnlLcx
         else 7oyG5P6hK7R^o
               return '>';FKG/P6j%Kfi
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>'; e3O#I | W'J
         else if(c=='*'||c=='/')$a Th7RGx
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';)dm|.z%JO3z
      case '(':(UT{8HpNg.j
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')#URzWL7p'k(ph
               return '<';
         else if(c==')')kicw/Q
               return '=';:K+t \uL6hO
         else+b"ON2F(|Elocn
               return 'E';
      case ')':;h5Xh1X6TO
         if(c=='+'||c=='-')
               return '>';8_Z"u&_A9GG0c\_W-v
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';wY.}!@$Fu4wsP
         else if(c==')')4g|.T Bq lQ]
               return '>';4lo}Bs8y)D
         else
               return '>';
      case '#':2x/j%VKM2_
         if(c=='+'||c=='-') Ajy+r3Q"a_,z
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';ShtG+{:q I
         else if(c==')')
               return 'E';
         else!Qo'SV0kzGEw#CY"z)S
               return '=';
      default:8BT"[.YB QB8O
         break;
}o/z_Vu f d|
return 0; 1H`;aE-V3a`
}m4UbB.E)I3pp4Y/S"G J

int isOpr(char c)
{T{M(fP
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')y"r#mY,q%X,c A&t
      return 0;,\n9?1a[&O0[]
else
      return 1;)X\nsq
}
Y7xwV \4VJ KR
float operate(float x, char opr, float y)@;F:R}jU9~#q_X
{5s2\pXD(o
float result;J!E^!r(?M
switch (opr)
{
      case '+': 1uc2x)t.A.A`Z
         result = x + y;e&_,@7U)b.s/C6o
         break;
      case '-':
         result = x - y;
         break;
      case '*': 6a5Y+g,A?L^&BY:w
         result = x * y;8A8k)Qp)] x-FoA
         break;
      case '/': _'A^ K\_a$Dy
         if (y == 0)QQ7p\$l)X^
         {
            printf("Divided by zero!\n");
            return 0;
         }
         else(A8@-kCho.d9yC
         {-Cc$_M*Z{'~$Z3O-V
               result = x / y;
               break;t q:^Z-u"M`
         }xmLE8A9rOh
   default: !oF ln)|"I'y3JH8v[
         printf("Bad Input.\n");
         return 0;
} X!YZVj5]Q A/G2O
return result;
} _p|f6B9^:q%]L

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{~2P.uiC
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;
}1sR1?.t"bnyG
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));,exc Xu-G%JU
V2qxx [1KZ@"w
printf("Enter your expression:");4eS!cb az
      V2B6?1e{~@/g
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();)K4xPq0~
while(c!='='||opr_top.ch!='#')
{!G5RjUs9g#A5O
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/ S6O:?[&j x0Q
      {
         buf[i]=c;} Aw:P6kRP#`x}
         i++;+tj5}W:g
         c=getchar();},BS\g1{)}:N
      }b5j!h.\ B}Gf:w
      else /*是运算符*/
      {!B4uLN5b*rD
         buf[i]='\0';
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
         {9c,fJ~a@Jf*Ok
               opn_in.data=(float)atof(buf);
               Push(opnd,opn_in);
               printf("opnd入栈:[%f]\n",opn_in.data);
               i=0;~A'lI,n.y~
               memset(buf,0,sizeof(buf));
         }(O1R`iD"y
         opr_in.ch=c;}E4?*`x.?Gi
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/(Y*]u@0?xo%U9q
         {
            case '<': /*优先级小于栈顶结点,则运算符入栈*/)VF0v7H8Tz
                  Push(optr,opr_in);
                  printf("optr入栈:[%c]\n",opr_in.ch);MHWO.t n%gU
                  c=getchar();Kp"wr&x*i0gc
                  break;
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/ qZl2\ ]
                  Pop(optr,e);XnlZh
                  printf("optr出栈:去掉括号\n");
                  c=getchar();
                  break;V BZ s7j N
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/8CYC(D"Z]9CB!s
                  Pop(optr,opr_t);
                  printf("optr出栈:[%c]\n",opr_t.ch);
                  if(Pop(opnd,b)<0)X9d%J$AnA
                  {&ei+L&dz_r
                     printf("Bad Input!\n");
                     fflush(stdin);
                     return -1;
                  }
                  printf("opnd出栈:[%f]\n",b.data);O3s_R!P
                  if(Pop(opnd,a)<0)3h3S-JJ(JS `P)gJ
                  {7xNl[TZ#W
                     printf("Bad Input!\n");"UwUWB5?-rR3O
                     fflush(stdin);le0i mDfo
                     return -1;
                  }p!d|(y!`,yOf%?
                  printf("opnd出栈:[%f]\n",a.data);
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/P)B et/E&nW8@
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/dxxg@k
                  printf("结果入栈:[%f]\n",opn_tmp.data);
                  break;
         }
      }
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             bKS2whtA Z/@sH
} hpOe*a XOH B
GetTop(opnd,opn_tmp);
DestroyStack(optr);
DestroyStack(opnd);
return opn_tmp.data;
}D3^TBS4T;B'uH2t

char *killzero(char *res,float result)1AXDI AJTX
{
int i;

sprintf(res,"%f",result);&^.s8Qtm,Edu
i=(int)strlen(res)-1;
while(i&&res[i]=='0'):J-CxZG)m['@E5j!g*N
{
      res[i]='\0';
      i--;E1B2GiJ`
}0|^L!Umbt d
if(res[i]=='.')
      res[i]='\0';8G.E)AlOGb
return res;R;@geje3h/~ M-_
}

int main()
{
char ch;
char res[64];xib$qJ3^c
float result;
while(1)#pd.~L(BMS't
{
      result=compute();
      printf("\nThe result is:%s\n",killzero(res,result));T)IV4\c0`YOf
      printf("Do you want to continue(y/n)?:") ;5QA'Y#Hi{!s
      ch=getch();?qd~%s-Qj%F:Kv
      putchar(ch);
      if(ch=='n'||ch=='N')
         break;
      else
         system("cls");
}
return 0;6`"VX/Y;I/Z:bh(`
}[/i][/i][/i][/i][/i][/i] x,?GF;u1Q,@$pb

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

页: [1]

捌玖网络工作室's Archiver

C语言表达式计算器