C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.6 Z! G, H* Y6 p* D% W
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/% w7 P8 v/ S1 q" n
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>1 K- t' s' ]7 d: ]" w
#include <malloc.h>$ A& N* Y& J; \6 }" r( v
& q- e! [% Q5 G7 a, c% b
#define STACK_SIZE 100" |" `( U& e6 e
#define APPEND_SIZE 107 c2 {  V9 i+ y- L4 o5 d

struct SNode{/ }' Z" S# {8 ]7 {2 F; a
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/. [8 L" u$ _9 P  u
};+ \. N7 F5 N9 h) M& U: w; H

struct Stack{
SNode *top;
SNode *base;) v$ N/ p% S! U! v) H6 R  m, N
int size;* v) X( G7 {9 O# o9 x
};

/*栈操作函数*/: c! V' S; ]7 S. @; |2 b
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/0 x9 @: n( c$ i4 U
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*// @4 V& `( [$ N1 C; J; L2 G
int Push(Stack &S,SNode e); /*将结点e压入栈*/% l4 b& X, p  z' X
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
3 h5 E8 h" g* g
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/* R6 \+ c, m1 S$ j7 M8 c
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
$ O: Q) p1 Q0 l$ p2 N
int InitStack(Stack &S)9 `$ Y4 I& b5 r. E5 s! f, O
{2 E4 O  I8 H* O
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{$ _0 W, g( x0 P% Z
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;6 d( K3 S7 V4 o/ i0 o
return 0;
}) \: G) `( k) q+ _  `: s
+ c8 ^9 ^" ^  @+ p$ h9 \- e9 |+ F5 S1 S
int DestroyStack(Stack &S)0 g) M- ]. R1 D
{
free(S.base);
return 0;% Q* N; O! Q, {5 W3 V0 O
}
' N1 ~+ v" d- j' n7 \
int ClearStack(Stack &S)+ a% C( I: i4 _' [
{, Q  H. h  M  M9 W- W
S.top=S.base;
return 0;
}4 G) Q. [  {# M' n; J2 a; b2 Y

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)
{
      printf("栈以为空!");
      return -1;7 C, A1 m! o: I+ }5 K& @  r
}
e=*(S.top-1);
return 0;
}

int Push(Stack &S,SNode e)2 s7 [# }4 a; i5 V. b
{! n/ B' X1 K1 c1 O. e
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");. O% s* m- f7 I. c! r$ o
         return -1;
      }
      S.top=S.base+S.size;) |) H( o3 \/ k
      S.size+=APPEND_SIZE;/ e$ c. D* b; x/ V9 i3 f
}5 Q5 r" {& y% A3 m, g! n
*S.top=e;
S.top++;
return 0;
}

int Pop(Stack &S,SNode &e)* D1 i. k' T  V+ \! A2 P& C; I
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);
S.top--;
return 0;
}0 Z) c/ o& z9 U; j; G) h1 K
0 u% @: Q: D' t6 Z2 a
char get_precede(char s,char c); k6 `  s. J6 |
{
switch(s): h: a) G2 W3 j  S$ G, z
{
      case '+':                ) B6 S- m' A4 e3 y; }- g6 D
      case '-':
         if(c=='+'||c=='-')
               return '>';% ]; A5 |5 f1 y3 U: T9 k6 Q
         else if(c=='*'||c=='/')7 B' Z1 h  o5 C7 Z8 {' u
               return '<';3 U) w' x* e1 O& D
         else if(c=='(')9 ~9 w% M0 X5 h9 b8 s5 k
               return '<';
         else if(c==')')7 M2 p+ w0 m, Q0 o
               return '>';! R0 W. c$ m( P5 N1 ^
         else & H* T, Z' M% F1 h4 @
               return '>';$ l9 L0 t8 ?5 J/ x% u
      case '*':
      case '/':/ I: f, N+ P' S; u7 e
         if(c=='+'||c=='-')6 Z9 D& n( ~( {
               return '>';& k! G7 m/ r7 ]0 a: s+ F
         else if(c=='*'||c=='/')9 Y* L: N5 c2 R
               return '>';* E# i! }+ H2 I9 c% m
         else if(c=='(')
               return '<';/ \, q1 V- l7 _9 q/ n
         else if(c==')')
               return '>';* ^( [$ G; c7 J' E  E4 K& V. S
         else, r/ B: |/ n! Z' B% g
               return '>';" z. w: k5 w, K5 n5 N: J( F6 ~
      case '(':
         if(c=='+'||c=='-')( |. u6 u% {, }# C  V% V
               return '<';
         else if(c=='*'||c=='/')! X! l7 f! g" U; r
               return '<';8 g+ Z" T  Q6 ]" x1 k4 o
         else if(c=='(')" b5 y0 g& I  d2 n2 i  n# ~( W$ P
               return '<';
         else if(c==')')
               return '=';  s1 o: ^* G! x- Q# }
         else  j. o+ F# b# H4 W5 e
               return 'E';+ c& n3 K! j" p( h
      case ')':) h0 O% j7 n( N
         if(c=='+'||c=='-')
               return '>';* V5 v; d/ Q2 P7 B- ~
         else if(c=='*'||c=='/')' M- @" @" j. p1 H9 G  d
               return '>';
         else if(c=='(')' k; j5 r7 N4 V8 L+ \4 T  E% b
               return 'E';
         else if(c==')')8 N9 T  ]# k' d# F  |' ^2 t& g8 R
               return '>';0 [) u! t$ i; R6 \- r/ E  }
         else
               return '>';
      case '#':' s6 V0 c2 Q: j7 \0 X
         if(c=='+'||c=='-')
               return '<';) G7 j5 l3 `2 B; K1 |, f; p' A
         else if(c=='*'||c=='/')6 I' i, r7 F( Y, m1 l7 c+ w/ g/ D
               return '<';1 T! K7 U  D$ g& z* ~+ w
         else if(c=='(')7 P, i+ {* m7 e- U6 M2 f
               return '<';
         else if(c==')')
               return 'E';1 \8 G5 {7 j  ^; Q
         else2 C  ?  z0 q5 z6 C5 X! h  V9 d+ g5 X+ S
               return '=';# O! u. @, H4 M
      default:0 S) C) ]5 ], T+ }" {
         break;+ _# \* I. |0 W
}, A5 q2 T, i9 v& p
return 0;
}# N( ^  e2 u7 M% U8 O3 n
- d9 w& t' V; Q/ ]" q
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;- D2 ?$ [( G* n: v2 r8 A! C
}

float operate(float x, char opr, float y)1 M7 c2 Y" E) B$ A# `& n
{) z0 p6 R% p& W) z" Q2 i
float result;2 _( R8 |$ e6 ?0 d. _' H
switch (opr)
{4 H$ T/ X) s$ N* h. p2 t* q
      case '+': 5 |9 `/ P5 A- c3 N$ N! \$ S6 k* F
         result = x + y;5 R6 e" s# V6 c- d& B2 c6 O% T9 g
         break;
      case '-': 3 v( i" Y  ^1 }  m  ^+ N
         result = x - y;5 C& A) w2 X6 W3 S7 i: m! Z
         break;" g2 x8 ]+ N1 m1 F8 h
      case '*':
         result = x * y;
         break;6 B  i# M- Z2 n* C  [
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;( ]; h' Y9 L# X; g
         }
         else
         {+ K  @3 I: l! S% m
               result = x / y;
               break;
         }
   default: 0 J; L1 [/ T  b
         printf("Bad Input.\n"); ' T- s5 s* z; v( B
         return 0;2 p; f& d/ [$ |/ T
}
return result;
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{$ R3 Y" O. O& q0 V9 y
Stack optr,opnd;1 P; \! v! ]4 ~+ D. x1 a4 i$ y
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;6 ?3 A- Q2 u( R; D2 g1 _
char c;
char buf[16];1 d4 V$ P. v! s. ~9 @2 ^. W# n7 M; ]
int i=0;# y, B! |9 ]5 J" i+ P) }5 q

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/4 _) J7 @# J8 F& P3 B1 j' u
memset(buf,0,sizeof(buf));

printf("Enter your expression:");
        m4 G4 A2 J6 S; ~. c
opr_in.ch='#';& U' m( ~4 ~2 [/ u
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/( p$ z; z, z" s8 F4 ~8 Y3 A: c
      {; u, q6 l3 d$ c6 h" v2 N! t, ]
         buf=c;: I9 H! Q4 P$ [( k: C
         i++;, v7 W( x1 K4 u  H/ {" `
         c=getchar();+ I/ `- B7 a2 [2 k0 g% Q; c) V) n
      }8 W, m9 V- j) o# `, _
      else /*是运算符*/0 m% x( j* t# J0 _) [0 V
      {
8 D. |6 j& }  m4 k% C          buf='\0';
) ~# f3 \, w( [; ^! {9 ?          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/4 Y) |3 e9 `+ d
         {) T/ o; t2 F" v0 s$ j: v1 m
               opn_in.data=(float)atof(buf);
! x% o2 m- R# h. g: j                Push(opnd,opn_in);& x9 [) q. K  J( D' Z& K
               printf("opnd入栈:[%f]\n",opn_in.data);
6 O9 n* a! z6 j+ r6 H, O                i=0;
! |, J  u6 q0 H/ l$ Q5 P                memset(buf,0,sizeof(buf));
+ R/ t9 h+ |; S          }( Q8 N! L- ~+ I7 \0 [6 S2 P* v
         opr_in.ch=c;
/ @/ z5 i! k, N( E$ r; j, t          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
! `  H3 c1 n1 g+ k2 ?' j. X          {
# n) @* G* j6 |2 ^. @0 J             case '<': /*优先级小于栈顶结点,则运算符入栈*/! [7 B  K1 P" r5 R8 s2 [
                  Push(optr,opr_in);0 T. x# Z+ [/ i, `1 s
                  printf("optr入栈:[%c]\n",opr_in.ch);
$ a, ~& u* a- N                   c=getchar();! k9 I  Z& i. v
                  break;
  S7 b8 A  J/ E             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*// J+ s7 S$ e& i/ c3 M
                  Pop(optr,e);
- ~  C; Z  D0 p                   printf("optr出栈:去掉括号\n");1 V( T3 D9 }0 F$ J8 z; ^
                  c=getchar();; W; o9 x( ~/ ]* _9 J4 K
                  break;
% i' g( @3 S- ~2 T2 g* E9 j             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/4 B7 S3 m) x3 O8 B0 c- X- H
                  Pop(optr,opr_t);
4 [# c2 B# o/ I  Q& o                   printf("optr出栈:[%c]\n",opr_t.ch);
9 b+ X& X3 _& O                   if(Pop(opnd,b)<0)
0 m  t* z. k1 Y$ j- h8 N                   {
; U1 O7 ]5 @; i0 j3 E                      printf("Bad Input!\n");
5 f. ~9 U% h- ^) X" f                      fflush(stdin);
' m- O3 T* f; V0 w- ~                      return -1;: I, h3 M2 ?6 U" F/ z8 w; F
                  }4 m& i; E% `3 ^3 W
                  printf("opnd出栈:[%f]\n",b.data);4 F& X0 z# C! h4 h
                  if(Pop(opnd,a)<0)
7 E7 r+ t, z, H5 L                   {
! n' q- n% ]: ~% y8 V3 j                      printf("Bad Input!\n");3 L" Q& \3 k' n( I7 F
                     fflush(stdin);
4 v. l/ G/ T7 ]2 T" Z, ^7 _                      return -1;* D/ |" {5 M; l  Z
                  }
5 }8 W% D: x* {+ n, {                   printf("opnd出栈:[%f]\n",a.data);) G" o3 @9 Z3 b# r/ R9 R; K
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
1 i. p# F# c) y  ], y& s* v                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/# W2 v; }% `: x
                  printf("结果入栈:[%f]\n",opn_tmp.data);
( _5 ~- T1 {7 ~                   break;
" m9 o! Z8 c; R& O$ l. C3 X          }+ x7 A6 l$ h( e# r  w- f
      }
" `2 t+ l; O+ x       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
( G& E7 L" e6 X7 k" L: Q, T }* r* r! w( U9 ^6 v2 j/ y, y
GetTop(opnd,opn_tmp);
' x- w3 A* `* k% Z. V; Z3 C) k; z4 Z DestroyStack(optr);
$ x" W' ^" S+ Y3 [: { DestroyStack(opnd);
" k# q9 a# F4 `. z return opn_tmp.data;
9 K/ r: X) P  X+ y2 ]! Q$ K}
, l% y+ F- D: ?3 v* X. C' U
2 @. d- |& U; @6 Kchar *killzero(char *res,float result)9 Q8 _7 N4 b8 m3 U
{# S/ R" Y3 K+ C9 e2 J, N
int i;0 B% W% B, f& i! I) n/ J  ]
: T. O% X6 R- {8 u; ~0 P
sprintf(res,"%f",result);0 W% O) j. }1 w5 k+ r( _
i=(int)strlen(res)-1;# \/ S& u  `0 q; ]' E
while(i&&res=='0')4 S: l4 _# w- j8 h; g* w- n  R
{9 C" |& J% R( F; Z. Y
      res='\0';; L8 R2 s' ?4 S/ |9 k
      i--;
0 K! K$ ~$ e. e* L5 ]* P; w }
* T. H' G# {2 ^ if(res=='.')0 C4 X) f; U& y9 }3 l
      res='\0';
" j8 q5 _3 Z. s; q+ R4 K2 X return res;
9 T- U: ?( ]6 D& b+ ~9 g}
! H, l/ F7 h: j: X( D" _0 X9 G
; J8 ]4 U7 o# T: B. d6 b: X' ^4 uint main()+ s- C. r) ^; G
{
& P1 h8 s% C. k. Q8 t char ch;
. a6 V6 V% A8 |9 z$ k5 ~% t char res[64];7 O! h+ \. f5 K  Q
float result;
8 l+ M9 P* f# I9 l, R, t while(1)0 S* ^% g8 m5 Y) N
{
1 f6 H) y- Q! K* O( l       result=compute();
  u6 x! ?, H& Q* [9 ~- |% k! g# `       printf("\nThe result is:%s\n",killzero(res,result));
( P  X" K$ C5 _/ ]. T& o: _2 Z/ N6 s       printf("Do you want to continue(y/n)?:") ;
- A/ Q: ?: P- k3 q% q       ch=getch();) x9 E- U& E/ d
      putchar(ch);
9 f7 {# t' g# b) l; p       if(ch=='n'||ch=='N')
: w- M% g+ H6 H! Z: K, s          break;
$ d- f8 U7 u, Y# X  t       else
: W: Z6 y; ~+ V& s, C. G# W0 ~$ {# W4 w          system("cls");. b& C/ R/ }$ R9 `! L9 F- X
}0 \# n5 S- t0 [: k) k
return 0;
# }+ W- ^0 I0 ~! G}/ k! j: G8 f/ c7 T/ b- |2 d- }
) V; K4 C. V/ l' h* u. w4 e8 P, }* W
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

[收藏此主题] [关注此主题的新回复]

[通过 QQ、MSN 分享给朋友]