C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=$ K# b- x2 Y, `4 |4 {1 b% {
/**************表达式计算器************/& m- d0 Y5 M3 {% X' \# E& v. N: V
#include <stdio.h>9 v5 d0 g1 m8 _  }6 O' L5 ^; {
#include <stdlib.h>9 p1 S3 k9 n. _6 V
#include <string.h>9 b; t# x2 @5 [9 z# [) B, a* C" k
#include <conio.h>
#include <malloc.h># f+ O  Y0 [+ w/ r
* n# P9 [$ k8 y0 Q, X+ O7 q4 c
#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/( S9 Z! _( x$ v$ r. h6 s3 n5 `
};

struct Stack{& y1 P" g$ N6 _  ^
SNode *top;0 T1 D2 v/ V5 b% G$ ]
SNode *base;8 Z# ~. e' l% t9 q% S1 ~3 X. ]2 [
int size;
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/& ]2 j5 r% v+ l! h; M# n( o
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/" G% t2 O4 {2 _: l- h6 w8 ~% Y/ U# }
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/7 K* b  f; o6 [/ Q# K8 o+ t
( z3 T# u" x6 Z7 m# Y, |  b" \4 d
/*表达式计算器相关函数*/( n+ o6 T  a5 I1 i+ @
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/9 v" [) T/ {# F5 u' e
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/1 I/ Y- z4 v- w9 M+ J
char *killzero(float result); /*去掉结果后面的0*/ 2 R: b/ G7 j! f" i8 r: g
2 r" P0 i9 N2 ^4 o! E
int InitStack(Stack &S)8 M7 Q+ \  W2 J/ b. J/ c
{4 P4 q$ {% {+ R8 k8 i" @
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));; J; B  l! w$ [! {9 L- D! w& Z' Q
if(S.base==NULL)
{
      printf("动态分配内存失败!");/ O$ F' m; O. j* G
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;2 o2 \( \5 o; `, e8 O$ a
return 0;' Q$ C+ J1 s! d: g1 p0 R/ _
}
1 J5 X/ T3 R0 r. g# D
int DestroyStack(Stack &S)
{
free(S.base);
return 0;
}; }* ^( ?2 d7 z7 U! d8 F- i

int ClearStack(Stack &S)
{' D: z6 b1 f% @
S.top=S.base;
return 0;
}! B2 z- @5 s0 @1 T! {, }
+ I$ Z3 S, l3 A! B( M2 W4 B4 J, l
int GetTop(Stack S,SNode &e), P  ?6 `& C8 u6 W0 i, h
{, @5 k4 Y  t3 z& J8 O4 V
if(S.top==S.base)- J4 d( t) R1 ]  V# o
{8 l! W, j; k0 a2 G2 G% z! Y  T
      printf("栈以为空!");9 H0 I7 i# c8 J1 W+ c0 R  y
      return -1;
}0 d3 _" n$ h9 ]  j* b7 n+ X
e=*(S.top-1);) K+ j6 ]% [! N0 d& u
return 0;5 K% [1 Y* _+ r9 T
}
5 u# M# h" ~: o/ D" V) o
int Push(Stack &S,SNode e): |9 _; M, S6 ~, ~; j8 K: D
{- J( {, x! P- c5 G: C# I7 E1 Q
if(S.top-S.base>=S.size)
{. @# L. r7 v8 d
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)$ }  a; I0 Z! d* Y
      {
         printf("动态分配内存失败!");9 P; `3 J' y+ ^+ [; ^; M' t/ c7 I
         return -1;  T( W% J: T# ?3 L' s
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}& x( f& v" D, \8 b, `6 f2 ]
*S.top=e;
S.top++;
return 0;" C! e& [. H+ t, _5 J7 Q( q
}

int Pop(Stack &S,SNode &e)) w, o. w) j* r$ E3 W
{; Q8 c: x( \- Q5 c0 A
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);7 t$ l/ b$ w+ u: w5 I
S.top--;; Y* ]8 T! R3 S+ g5 _/ E
return 0;  N. P# o6 o5 a
}
1 G' E$ N! w- p8 D
char get_precede(char s,char c)4 u2 @, K$ ?& s" ?( z
{! P* Z3 L- h  \; u
switch(s)
{
      case '+':
      case '-':" M1 M- \. ?& x
         if(c=='+'||c=='-')
               return '>';0 e# \" z& S, [4 I3 }
         else if(c=='*'||c=='/'). o, b; g4 g2 P1 W7 A) L: b, S" u& @
               return '<';: a: X: ]$ P2 n% S( `2 ^
         else if(c=='(')$ W" a2 m  @7 P- f
               return '<';
         else if(c==')')' h( Q2 L- {# \  V0 i' ?
               return '>';
         else 3 P8 J8 y2 I8 j
               return '>';  |: M- d! T8 E4 ~
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')  p( R( u  e: X3 s4 b
               return '<';
         else if(c==')')% B# D* J4 _: p1 o/ Q4 L9 @1 C6 a
               return '>';
         else( k$ d" v. H$ T* a. X. V
               return '>';
      case '(':( O2 O$ ^/ t: }; U
         if(c=='+'||c=='-')
               return '<';5 s% \. K; F3 F" S8 R# e
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')5 \; B# b2 J' h+ E9 y/ t
               return '<';2 {$ j* K" \* O! u# X" L% d9 |5 n% u
         else if(c==')')" Y+ Z- i4 f. X! E$ l
               return '=';9 f/ Z" o" |* }6 Z% b& R
         else
               return 'E';- Y3 M4 r) y9 E
      case ')':
         if(c=='+'||c=='-')$ m2 [) G9 I* K
               return '>';
         else if(c=='*'||c=='/')2 R! N+ b  P( M) V
               return '>';
         else if(c=='(')+ L- \5 Y8 @0 {4 ~/ J/ p) @
               return 'E';
         else if(c==')')
               return '>';$ R) w# I- g. @' w  }
         else
               return '>';3 L8 g5 X7 I* G- n
      case '#':; ^8 ?* K" V' f  j- {4 x3 K
         if(c=='+'||c=='-')  ]: W1 P+ V" R& K3 o
               return '<';
         else if(c=='*'||c=='/')* [' h1 e9 I( J/ {
               return '<';# L+ o$ C4 U& s, e0 [# K: ?
         else if(c=='(')3 M' q9 e3 {; I8 {4 ?
               return '<';) |7 t% E; d, L1 j
         else if(c==')')+ T! [2 B) f7 Z
               return 'E';9 z+ v4 O6 A6 @9 B! f/ Q" Q0 o
         else- E' n" a; f0 w3 G
               return '=';- g4 S8 @- e- ]4 j  L: Y# T2 ]
      default:
         break;
}; j, Z1 j$ L9 z) ?' ^* x
return 0;
}+ w6 t; o7 y) d4 M  i, c6 |2 {$ i

int isOpr(char c)/ l$ R5 C2 c3 x- X( l7 U
{2 l1 o6 L' X) m8 c0 i2 r
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')6 [( \! J# H7 w: E5 T, r5 t
      return 0;2 p1 w7 A- J3 [, L4 C
else
      return 1;
}4 b! F5 A0 s" [( m

float operate(float x, char opr, float y)) T- D( I. Q+ e  o" t) b. x
{' i; f* C, P  X
float result;
switch (opr)5 k8 F' u5 A! T2 Y$ ]
{
      case '+':
         result = x + y;
         break;
      case '-': " p( f9 f  \: N- s
         result = x - y;( q' a9 `4 L1 w- ~& z( l4 [! K7 z
         break;& W" a' v3 a! a" p
      case '*': + j8 d  `2 X9 U% M+ v. V6 z( l
         result = x * y;
         break;; E- n' _$ t) q% T/ c" c0 |3 w) C
      case '/': " z+ Z6 [( P( a& Y) V" a
         if (y == 0)9 s* v& k( k: w' F
         {
            printf("Divided by zero!\n");
            return 0;$ s* O1 J, ~6 J" @4 \/ a3 R! f$ z
         }
         else
         {! u  P: u! r+ d0 v; _
               result = x / y;
               break;
         }
   default:
         printf("Bad Input.\n");
         return 0;* v- N' }* [) J7 H; Z: K8 F- W' R
}
return result;
}   \& w& S& }" M
# X, C8 d! u2 n# g* s: O
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;9 }  f+ S$ r; G9 M" y/ k
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];/ X2 {1 `' z. {* X; v" V, G
int i=0;* _6 V( i8 o2 P; s7 c5 H
! b! E3 N7 L: \; d
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");
      5 M  @% C. r4 [, I- a# s
opr_in.ch='#';+ E+ k3 W8 g# s2 q. c$ L
Push(optr,opr_in); /*'#'入栈*/) r# ~: t' X% G$ u8 X
GetTop(optr,opr_top);3 |3 E$ y% j2 n  g
c=getchar();
while(c!='='||opr_top.ch!='#')/ b& P6 ]" f$ d; x8 k
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {% `# Y: h: n* M* ]! v
         buf=c;
& c; h6 ^$ T: J* P# @2 T          i++;% u/ P( y1 D& x' z# j# E
         c=getchar();
- P3 y1 x* y7 Z' x: o       }
' |$ o2 v, M1 ]       else /*是运算符*/
& ]0 F+ y5 ]3 P/ O, n% X2 Y. ^2 P  j       {  i1 P3 h& V) @2 ^8 \
         buf='\0';) p6 q, T: t) h
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/3 U- R+ x- |0 x2 i. X
         {
$ s) E8 d* {/ n- l1 J* _                opn_in.data=(float)atof(buf);- `+ R2 [8 ]" z0 Z
               Push(opnd,opn_in);4 g& D9 ~5 P, F7 y* f
               printf("opnd入栈:[%f]\n",opn_in.data);
. E$ h* |/ n6 D+ V: e$ W( \' H                i=0;
  Y* w5 R' C. w5 ~                memset(buf,0,sizeof(buf));& @5 |4 {% |8 l  l) p7 M; q& i
         }
; W. z) O6 [1 p- p  p. e) O+ v: T          opr_in.ch=c;$ F# _9 ~- q  k  ?  Z1 f" c
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
. ^, Q- q( U4 o! o( g          {
! M  A% L$ {  j1 M% A             case '<': /*优先级小于栈顶结点,则运算符入栈*/
" u; ^4 G3 c+ v                   Push(optr,opr_in);
5 M% n3 a# \& a$ W7 V                   printf("optr入栈:[%c]\n",opr_in.ch);  K- I1 m) e5 A! ]
                  c=getchar();3 I: u, p# }6 `1 F& ^& B
                  break;
6 [3 d- f. O& a# |             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
( W  g) M4 b3 M' h3 T( f2 \                   Pop(optr,e);! f' h$ M: d0 q& H4 n" R
                  printf("optr出栈:去掉括号\n");' U% x3 t% B. c4 Y( W, u
                  c=getchar();
# ]( H1 ?$ }$ U3 X* _6 t/ z                   break;
9 Q5 j! ?0 f, F% \, V" _% u: B' I             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/, A: B, D  d1 z2 r9 b4 c& O
                  Pop(optr,opr_t);3 c) ~1 q+ [5 ?
                  printf("optr出栈:[%c]\n",opr_t.ch);
: I% R& O% ?( [& f                   if(Pop(opnd,b)<0)" z$ n( L5 z1 [8 M
                  {0 W2 D3 o* i; ~  s: k
                     printf("Bad Input!\n");
: K8 Z, ^/ g- D                      fflush(stdin);5 F4 A/ E. @& F4 t6 g
                     return -1;
2 u3 I' _6 B: ~- G! a; Z5 @1 I  l                   }
' }4 L+ z: J1 p/ \                   printf("opnd出栈:[%f]\n",b.data);
  G4 K& F; T9 j% R, a8 E7 J                   if(Pop(opnd,a)<0)3 N: Y; g' z; T% q2 S; a. o
                  {
+ C% b  ]) z  |' c                      printf("Bad Input!\n");
0 Q2 y/ R& F+ A* N                      fflush(stdin);& W+ B( q& I/ r  e2 B1 m8 `, I  B+ i
                     return -1;
0 Y. h+ ^7 R( e" M% u6 z                   }3 h. V7 n5 ~! J  b% [. w
                  printf("opnd出栈:[%f]\n",a.data);
. M8 ]1 w. J1 f! D* T                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
' I2 {9 N& e4 k) D# ?* f                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
; |3 i  K% ^( p. s3 |# ^* q2 E% P                   printf("结果入栈:[%f]\n",opn_tmp.data);* y' i  V7 X3 @) P9 f2 H$ \! m
                  break;6 M7 z; w1 u( H% n2 T6 v6 D: S
         }/ T. d% o$ I1 u+ D9 N% B
      }
. O: l! S8 u3 W6 m* M& ^       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
8 {3 \( x  A4 O' e: P }
, N" C  a9 A0 V) G$ ?6 ~7 e3 ~. B GetTop(opnd,opn_tmp);" [( w. y: |$ Y9 f% b$ ]- k; _
DestroyStack(optr);
5 V$ X$ n/ }* ~7 l; M DestroyStack(opnd);$ j0 P$ K$ k; B
return opn_tmp.data;9 A: n( G- m; y( a2 {# e
}
+ W) e! }1 P3 {8 L* H
1 K* ^0 B/ i3 i% A+ hchar *killzero(char *res,float result)
& }% l) |" x( q  Q7 }{5 h9 j. A  K. a% g* c
int i;+ o% J1 b' ~$ R, ~) g$ `7 ~4 H; S' i4 s
  Y0 l- J3 z; }1 K
sprintf(res,"%f",result);( V# G  z4 b' Y9 h. }3 ]
i=(int)strlen(res)-1;
8 M; [: U. p% L0 Q- L while(i&&res=='0')
' W7 l  @# A& ?8 B( J* G6 ` {
6 f% r  [# b& ~8 \: V       res='\0';3 \$ V# `# ?% `9 B3 c
      i--;- P; [2 s5 a' M0 c7 b! d) g0 _
}! a$ l7 [# {; ]2 r8 y5 y: s% B
if(res=='.')
7 D% A0 @4 V1 R       res='\0';) |# ^1 o  M1 D6 s
return res;
, r: I: S- d. O$ O2 g}
" e! \- P& g% t
" o( }" {. O3 F0 }- L/ W4 o2 g: g# vint main()
7 O5 @4 z8 S( e; E0 \{# l# _, K9 p5 {: x
char ch;
% P8 {% W7 V' h3 p$ S# ~0 C, m7 F char res[64];* v! C; ]0 z+ g, ?
float result;
% S6 p; G7 g. k while(1)
% C" G' ^0 g3 I! f3 T0 k# V {1 [: L* O+ r# A: u
      result=compute();
3 ]  }7 ~# j% W& F* X       printf("\nThe result is:%s\n",killzero(res,result));  H% ~/ c1 o$ s5 z+ f& Q
      printf("Do you want to continue(y/n)?:") ;
+ |6 h0 X" i3 f' Q0 b       ch=getch();
# H( K  Y+ p! z1 ]% t       putchar(ch);
& C  f2 t4 ]3 |& B% Z       if(ch=='n'||ch=='N')1 _2 D9 n+ B! M+ j4 _
         break;$ s+ h" m- m  V- _0 C4 W9 [1 f0 ?
      else
- P' q/ u0 X+ b' J( M          system("cls");  S' v! h! U5 T
}. Y  `) H2 _  y/ ~1 X  ]1 \, ?
return 0;
6 J3 Y9 R  ^+ T" [' p- c}
) e$ n, W( M2 [& r1 J) z
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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