C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.2 j% f; X: P+ G# `8 u2 ^2 S9 ?$ Z
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/1 o  [9 v' I* a0 V  b4 w
#include <stdio.h>3 g( K4 A1 I4 L7 N: u! o8 M8 R
#include <stdlib.h># j4 j5 d3 @) `4 }
#include <string.h>1 Z# g6 `2 j: W+ Y( _: L
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100+ r2 G! c( i1 d+ S# l8 W' A
#define APPEND_SIZE 103 g& a" i$ y! J5 y. `  n, U
( ~/ v$ a) N5 b+ @
struct SNode{1 {) V- C) u( `4 I" x
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};8 T( P0 Y# B/ |; d

struct Stack{
SNode *top;! ~" a6 K$ E+ ]$ }6 g
SNode *base;5 c' }, M, A% i8 F1 ~+ _; c
int size;
};* o9 Z0 u% ]$ S# ~, x
+ |' W+ h9 W3 Q' J* E& [
/*栈操作函数*/) V" l+ S& o3 u3 f& I
int InitStack(Stack &S); /*创建栈*/) x( W& v8 g  a6 {( E2 v5 |
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/, w  I* Q4 M8 L" ]4 {6 ^
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/% G* ~9 I# [( b5 X- c( c' S
$ e3 a, ]4 \7 I3 d5 l
/*表达式计算器相关函数*/. s  O0 k+ k) Z) x- J6 f
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*/ * `9 B" t: r* p0 E

int InitStack(Stack &S)
{3 ~# G7 O3 X/ @) L5 f
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;& K" W8 \. t0 P0 A: S8 s
return 0;
}
) Z, g6 j: M( f/ D" V, ~& D
int DestroyStack(Stack &S)
{" E0 D& y% {, p4 g1 v& T; h7 m! z. O
free(S.base);
return 0;
}  e7 s$ C/ Y7 ^* M$ f# z8 ~

int ClearStack(Stack &S)! Y9 q- ]) h8 g) j% J# H
{
S.top=S.base;
return 0;
}

int GetTop(Stack S,SNode &e)
{3 v9 E; v7 j  ]( {+ i
if(S.top==S.base)/ @3 d% G0 I# i  G
{( U! ~* ~! o( T8 G0 b  _: }* }
      printf("栈以为空!");
      return -1;
}6 a/ ^- b' X' E4 I
e=*(S.top-1);+ q5 _1 a0 Y) P: H  D' s
return 0;
}9 J- {( x+ @3 \, c- z
  r, E/ p; e* j* X7 A6 r6 _
int Push(Stack &S,SNode e)' l, @! S- q# x, |1 d+ [( h; B7 a
{. N; l& Q+ L# D
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("动态分配内存失败!");
         return -1;/ [0 f' t. N7 O- C
      }
      S.top=S.base+S.size;1 S3 O+ @- X% a- B  n3 l8 n
      S.size+=APPEND_SIZE;
}/ `# g8 J3 _5 z  S2 }! r
*S.top=e;
S.top++;- f* Y% v% w( f3 T  p' P
return 0;
}8 i( ^2 ~; _2 \( G

int Pop(Stack &S,SNode &e)4 e2 _$ z" Z: I
{6 o7 K9 n# c" {
if(S.top==S.base)
{
      printf("栈为空!");% f& \% ]6 E) ^, _) ~
      return -1;$ V# Z% z& r5 q+ t* A
}
e=*(S.top-1);: H2 H9 {' Z% }! ]
S.top--;
return 0;* y/ J. Q: N8 v; H7 ?- E7 J
}% A( G% _' Q1 b4 r

char get_precede(char s,char c)
{
switch(s)# n6 N: u% @" D2 g0 g# H
{( |6 x5 l2 Y6 y4 Z& b
      case '+':
      case '-':# f* F( A9 {6 @4 u' w' `" V
         if(c=='+'||c=='-')
               return '>';3 }, O3 Z' [4 F3 j) o. E! H; |
         else if(c=='*'||c=='/')
               return '<';: O' a% `1 A& y. A% b6 T( r& E1 [
         else if(c=='('): h/ w" y" ]2 y2 z
               return '<';4 G, [3 h8 \1 l- U! c, x, {
         else if(c==')')
               return '>';
         else ' s: h' ?8 q0 D2 e
               return '>';) X# U: I  `/ M) q9 T
      case '*':, h6 k( _  S; B2 V9 `$ }
      case '/':- c2 |% w. ?  v4 F6 y2 Q
         if(c=='+'||c=='-')
               return '>';+ l& r8 _# r% B9 W& K
         else if(c=='*'||c=='/')7 O+ g% }! X/ K% Z% s
               return '>';5 Q( k% I/ L! R  J
         else if(c=='(')
               return '<';
         else if(c==')')+ c! M! ?0 i# z- U- t! e( W
               return '>';6 A4 V- N1 k! G+ s4 Q
         else, ~1 `# ~, \& B: C
               return '>';
      case '(':$ `2 [! B. ?8 k9 s: v$ E, W
         if(c=='+'||c=='-')$ c* A, ]$ Z! ~; |
               return '<';7 K$ q2 ^3 j6 m) U7 N( H0 E$ b/ n
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '=';
         else
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')- |, J3 U/ s, I4 M+ @7 }
               return '>';) B& L$ K* `' V% n5 e$ _( q: Z
         else if(c=='(')
               return 'E';
         else if(c==')')
               return '>';
         else
               return '>';8 X* I/ L# D- }5 F& d
      case '#':' R3 s: P- `; _7 A& l
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')2 p; C0 }8 G% r% s+ Q/ z" R3 O0 L  [# O
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')' d: K3 }( g* p3 x. j
               return 'E';  J0 u: p+ n1 K4 x3 R
         else
               return '=';
      default:1 X! p0 l$ C) V6 b! }
         break;9 N8 }+ B3 e9 T6 M, [
}
return 0;
}0 ~' Z# A# V: ]4 x
8 T/ N) g$ s/ T" p; D7 y/ e
int isOpr(char c)
{6 C8 J6 `5 b9 i4 @/ d
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')- o; c' q. R5 I9 G- `! a
      return 0;
else
      return 1;+ @1 m  B6 a+ U4 r1 G* }; s
}4 j! Y5 C; \( f9 U- E& X: A: h$ j
2 H5 V+ I- E$ A# H) |9 n& j
float operate(float x, char opr, float y)* B+ W7 S, h, N
{) N9 [- a& M' Z1 @
float result;
switch (opr)
{
      case '+': / F1 E3 \" `( n9 d! ?4 z
         result = x + y;- W. \* n, I% r" W, E
         break;
      case '-': 9 p' W2 Q  B6 D6 b) i& s
         result = x - y;
         break;  j* [) R6 U/ i, R  ~% b' {
      case '*': 4 s2 s5 z7 T- ]2 @% t
         result = x * y;2 s# X" D; o: A/ r
         break;
      case '/':   C% P+ [4 E7 `1 i1 _) _% a, b
         if (y == 0)3 }: u- m* k! y- ~+ i' u! g2 X9 \4 g/ b
         {
            printf("Divided by zero!\n");1 p6 m: ]8 c4 B
            return 0;
         }
         else
         {* c, F! B4 p' a/ \
               result = x / y;$ I# `3 r4 F3 L; r! [
               break;
         }" ^3 \: x5 v  t) d/ n
   default:
         printf("Bad Input.\n"); . x& T2 ]+ F$ m7 o2 G8 G
         return 0;( {8 B/ [3 i3 u
}
return result;
}
# J( u1 |5 b4 J% V! o0 j9 D4 e& ^
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/  b8 B, S4 M1 D7 |
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;( n" O1 _& s$ E% {$ z
char c;( `  H8 @) d) N. d
char buf[16];. l" q4 U) D/ c9 {
int i=0;# U* I# ]1 J  u6 n  e5 s

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/2 W! Q! \. U* q- `# b5 F2 F
memset(buf,0,sizeof(buf));% R3 ^/ Z  u2 H9 a
& f# J) B. h; \' t0 A1 F
printf("Enter your expression:");3 X( a: F) K$ O  v' h

opr_in.ch='#';; W0 @& ]: u6 t) q6 K
Push(optr,opr_in); /*'#'入栈*/, g. C) M! h  R" q3 }9 [: j5 b
GetTop(optr,opr_top);9 w( o# E9 r7 `$ p; @  J0 ]
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {5 \' O" O7 w0 c; p6 b
         buf=c;% h4 f2 }( P) Q: i
         i++;
: I9 k1 U: y/ N          c=getchar();+ c2 x) \6 Z# H0 t
      }+ ]. b$ Z1 J2 I  J
      else /*是运算符*/
2 D: x6 A& @# m% P  s       {
7 k% [1 A) t, t; V$ p5 L          buf='\0';1 j5 A) ~+ M& t" y1 I
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
0 b4 A% y+ x) k8 d& k          {5 K1 G, H4 g& Q. @" Y% ~
               opn_in.data=(float)atof(buf);
. b' @  L- B  d                Push(opnd,opn_in);- p! [0 U6 p/ p$ q7 ?
               printf("opnd入栈:[%f]\n",opn_in.data);
: ~7 y: x0 c5 j: k( B3 G$ w                i=0;
. j& N' R# M! u( e                memset(buf,0,sizeof(buf));. Q( v, B) G# b
         }
& e' b. O' o* T/ \          opr_in.ch=c;
/ z4 l, `) b# v& i, ]5 o          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
6 D& d. X5 \1 h          {
# U, e. Z/ |! q! S  x6 r             case '<': /*优先级小于栈顶结点,则运算符入栈*/4 U4 D) j. U6 Q1 ~# p
                  Push(optr,opr_in);+ o; `% i( }4 _* T/ a3 b8 G
                  printf("optr入栈:[%c]\n",opr_in.ch);+ k! W7 T% D0 G
                  c=getchar();! x) h$ A6 I2 L; o0 u# }( @
                  break;
8 ?5 N, A+ J# D& o* G8 Z9 B             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/, |" q$ z: s. T0 t
                  Pop(optr,e);# }6 W5 x' S/ [- z; D9 i
                  printf("optr出栈:去掉括号\n");% ?9 @2 `* E9 T8 b. t/ D+ T
                  c=getchar();. _/ \0 B  \  `+ ^/ |8 @  D
                  break;. y0 X% n. @1 H( Y
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
& [5 k+ ?) s3 S" a                   Pop(optr,opr_t);% I) [( G( i) o- j9 Q; K& N" U2 X
                  printf("optr出栈:[%c]\n",opr_t.ch);' t9 V) Z) [3 i! P5 @. {+ A2 ]
                  if(Pop(opnd,b)<0)
; i6 N( Y, C  }; ^                   {
4 T2 r( f2 B9 C9 z1 f' `                      printf("Bad Input!\n");- Q6 C2 r( H9 P- O+ r1 L
                     fflush(stdin);
- j  H6 _3 p. X) o9 g# K& Y                      return -1;
0 Z* v& \! U9 c6 O                   }. E' S$ i" e4 s# C! c
                  printf("opnd出栈:[%f]\n",b.data);# f4 q% ]. \3 T
                  if(Pop(opnd,a)<0)7 P" ?6 K# m# [1 o9 j( k
                  {
. w+ Y' R  e# B& K                      printf("Bad Input!\n");
# e4 p, N/ d- _6 ?                      fflush(stdin);
( b8 s) _3 f) n+ P' B! A2 U                      return -1;9 X: |  M$ D! J
                  }
8 R; H5 r* Z* h/ O                   printf("opnd出栈:[%f]\n",a.data);
4 c6 e2 E8 `: F, }( Q) S                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/6 k2 {5 L- S: s- g, G6 w: r
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
0 v: ]3 ~$ ~: |& S                   printf("结果入栈:[%f]\n",opn_tmp.data);
3 o# r5 v: v$ [! w1 Y, W" |                   break;  y# y  N1 N- }& `. B
         }
7 Z! i( ]( L2 ~) m       }' ]" a  o1 p, K5 {! L* t$ b
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
. D5 U9 Q, z$ h8 u/ M+ w  z }" O  b& o: h" D* P1 ~+ m
GetTop(opnd,opn_tmp);/ I% S- u& i( c0 H( m6 r% s
DestroyStack(optr);0 c1 Z/ A* Y( T0 i
DestroyStack(opnd);
8 h+ ^9 |# W' P return opn_tmp.data;8 M( E' Z& _2 r9 @' J. \& A
}2 x9 D2 L' C+ |& A5 X3 u  }3 o

7 {" ~( o/ g" i8 h3 mchar *killzero(char *res,float result)
& F% u, V  L  D{( k$ ]" s! V6 k4 ?# G2 T
int i;
/ ?* X) |# G4 }0 @" w: p% ^" P; S- B+ U6 C- A3 @2 ?
sprintf(res,"%f",result);
& {7 N: f; N2 |! V% S$ v0 { i=(int)strlen(res)-1;( e7 m; t4 G7 I3 e
while(i&&res=='0')
" a7 ?5 G* q9 y3 p {3 A8 e/ R, B- f$ C. u
      res='\0';8 ~, R5 c  R; h, E
      i--;3 e- L3 G: s* z& S
}
7 j" }0 b1 M& l( f8 i8 B( q* K if(res=='.')! n) ^* V2 K, }! D+ W* B  W; V2 g/ U
      res='\0';& k2 H0 t' X0 Y! q1 e4 u9 g! `" ~4 t
return res;& c; g. g* Z- [
}8 p  f, N9 L8 x" I7 E0 ^

+ [, r# t  V; H( w% V  [int main()2 p( w$ g3 ?& V1 v4 p5 A
{5 K' T  ?3 }% V7 I
char ch;  I) c1 M3 T; z" d3 r2 @
char res[64];
. x% A( h5 ]) h: \: y float result;
, Z' h% b* [+ x, V7 I( Q while(1); o% \- e4 t2 w6 O7 F
{# G/ E8 q% v6 t7 ^
      result=compute();
6 ?* |. S' }/ k* d) u0 b       printf("\nThe result is:%s\n",killzero(res,result));6 N6 R! T' q4 P
      printf("Do you want to continue(y/n)?:") ;
0 ^' M! [3 o+ ?( _. K" n# _       ch=getch();
& t) I( p2 \5 Y& h& k' h" [       putchar(ch);
/ z* X. ~) D) r' D+ N       if(ch=='n'||ch=='N')
( h7 z3 f+ g2 i/ A" y+ @4 ^          break;8 ]4 Q8 R2 |  r- G( A; [
      else2 ~% E- I% E" E8 i
         system("cls");0 @8 u, s+ @( B. S% b
}0 V- @- b% t; I7 W3 M2 r4 Q0 [2 R# l
return 0;- V/ q" n5 t& [/ e: g
}" F3 C0 D  Q- d/ w( C% z
% H( r# J6 L5 ^) p& w8 L4 L
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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