C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=+ b2 ^! c# T! n( s/ e) w
/**************表达式计算器************/% y- U2 c/ U, ?7 ]8 H+ E
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>6 K+ |! W7 L" h# X4 }

#define STACK_SIZE 100
#define APPEND_SIZE 10
+ }: u  {$ u2 R; j) @
struct SNode{* d, V. s, q( N  l: f, {
float data; /*存放操作数或者计算结果*/* P( a7 ?' q  k* k" V! |
char ch; /*存放运算符*/
};; Q* P' W1 P* k0 M

struct Stack{, @, ^6 r, a  U- w# ^" t
SNode *top;
SNode *base;
int size;
};

/*栈操作函数*/- Q6 O  U" F+ T+ }* K: C# }! a
int InitStack(Stack &S); /*创建栈*/% a6 t3 g! I7 j7 ~# P
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/2 @2 U& B: S7 Q. L3 t% g  u6 |
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/0 w, H) p+ d+ @, Z$ j& r" j4 L
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/1 l2 R" E7 d6 l2 N4 S7 q
  y1 p4 b5 q( d% w" t
/*表达式计算器相关函数*/* S' N8 Q8 [) g1 p9 A, w
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/  C! V' w1 T% ?' S1 \4 g
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/$ l) y9 h9 {5 e2 R7 ^
float compute(); /*表达式结算器主函数*/6 U. u+ X$ k% r) j$ s4 N
char *killzero(float result); /*去掉结果后面的0*/ & G# r- g* U3 L" n: \
2 u8 {/ w; X, S6 H. m0 ]1 _. a
int InitStack(Stack &S)+ N5 C/ f+ r; X, @- G  g/ l
{6 s, f3 v/ Y  k; }( c; N& _' }9 ^
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));& ]- I* d4 p& N: y7 z
if(S.base==NULL)
{
      printf("动态分配内存失败!");- _7 X8 M# M  e( L9 f
      return -1;( v. \5 ?7 f- A# U1 J3 q9 v
}" N4 S/ B% f7 H! S
S.top=S.base;0 X5 ~: O+ u7 R
S.size=STACK_SIZE;/ @, }3 \8 i2 r* \% w! d7 {
return 0;
}

int DestroyStack(Stack &S)
{/ W. `; f6 J( Y* B! X' ~# D% `4 }
free(S.base);
return 0;% O) W+ c' v+ T
}
$ L2 e; ^3 V, K5 F/ w; B
int ClearStack(Stack &S)
{# |2 h  s6 p$ q; I, X- _" k
S.top=S.base;4 G3 }, C+ Z6 N0 z' a0 a
return 0;5 _. U7 A# ^4 ^5 q6 C( k
}
7 p+ [/ U8 ~* p# t0 h" I
int GetTop(Stack S,SNode &e)
{( b( I) o  e$ O5 R0 l& j
if(S.top==S.base)( ~9 \6 [0 a' a+ X
{
      printf("栈以为空!");: @) M8 ?3 E5 f/ j
      return -1;$ O4 A/ f: v' K/ S3 v: n5 f
}2 s8 N# M- O$ `/ Y5 x
e=*(S.top-1);% R" b- K) `4 {9 N) a5 z5 J
return 0;
}
2 F# ?$ l( w! A7 _, J7 G
int Push(Stack &S,SNode e)
{+ `( v5 e' U' C1 ^, m9 e; X
if(S.top-S.base>=S.size)
{8 o0 d; p2 t8 I8 y" h* U5 C
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {9 ^$ k: S- X: J9 \5 W9 u
         printf("动态分配内存失败!");
         return -1;
      }  r: K% P, r  u( g$ O
      S.top=S.base+S.size;" c" j% U, s, Q) g
      S.size+=APPEND_SIZE;
}6 q' G4 J* d$ f& v; I# K6 Q1 v
*S.top=e;- s# j6 j( S% P/ ]; Q: R( ]8 t
S.top++;
return 0;
}& h' l; Z# _. ~# r  Z) _/ V

int Pop(Stack &S,SNode &e)
{0 k1 F( N! [8 n. B0 ~9 F& q
if(S.top==S.base)
{- _4 W5 v8 J% r
      printf("栈为空!");* u. s4 R* B6 h! ^
      return -1;$ Q5 S. O. W" h/ ~0 e, n
}
e=*(S.top-1);. X# b: Q% }' r: L3 Q
S.top--;8 ?! \8 f8 s9 d; w) J
return 0;9 l  [5 ]8 H( b4 N
}& U* G' G( l3 m( }
1 U. e) Q% ^' Y, ?6 f
char get_precede(char s,char c), D5 A  O2 f: M8 s. x& c( B$ N
{) ~$ e" D+ ^. m, t: [5 C
switch(s)& q. ^- ^  _3 Q* _
{  R) Z3 r, ^0 x1 w& i- X/ x' J
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';6 a) ?; ]' B3 [( p. U' k
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';' m! ]. g6 l6 p/ N8 S) Q
         else 3 F9 B9 Q( q6 l7 m
               return '>';) E0 v# U+ q  a; Y
      case '*':2 \% n; }; R, V  j  u' G/ M
      case '/':
         if(c=='+'||c=='-')) ~, }7 D, [6 M. |2 \, z6 c
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else( m, Y, L' M! x$ ?5 x
               return '>';
      case '(':2 r( |8 D% s" ~  [7 O
         if(c=='+'||c=='-')4 r/ Z/ F5 Z2 ~, c  A* s& `2 \
               return '<';
         else if(c=='*'||c=='/')
               return '<';+ S6 m2 o! N8 a7 ^* O
         else if(c=='(')1 B$ k0 o: P7 Q
               return '<';$ d/ A/ T7 X: s0 U0 G7 m
         else if(c==')')6 `  q1 j6 [2 O/ K8 t
               return '=';/ A9 I/ _* h) N5 O* I) C' ], C* M
         else/ P! j, _9 W4 E8 Y
               return 'E';# I) e( p0 @- A8 o
      case ')':: F# O5 m/ D9 g# r7 S
         if(c=='+'||c=='-')) U0 o3 Y! h% Z$ F( }
               return '>';
         else if(c=='*'||c=='/')
               return '>';5 @* f! }. ~* q/ `" B" X7 ?! w
         else if(c=='(')
               return 'E';
         else if(c==')')
               return '>';
         else# s3 t) o/ N+ G& X
               return '>';8 c2 M& ]/ v& ?6 w
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')8 m) ^1 F, O% y
               return '<';
         else if(c=='(')! C* X5 N4 n2 W, a& L4 r
               return '<';
         else if(c==')')( G( g" M; Q7 ^5 [
               return 'E';
         else
               return '=';
      default:
         break;1 J2 H% `9 q  b2 ^
}
return 0; , z# g# D0 Y0 B6 f1 f6 Z+ O
}
5 J& j% K- d& D8 a- ~
int isOpr(char c)& o1 E5 f% i) T: Q# q$ E
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;) w( ^( ~% S6 i( o* }
}% v% e" G3 m; ]- R3 P5 }: z& l

float operate(float x, char opr, float y)! n) b( t; s" L$ @
{
float result;
switch (opr)5 r7 U9 D8 e  j+ O, B. ^6 ~: I% L
{( R% X: S& Z1 I
      case '+':
         result = x + y;
         break;  ^% [  X. s/ h) i
      case '-': 6 k1 t$ k& O. y3 O2 x, K+ E  o" k$ t
         result = x - y;, N7 M1 J; R7 @/ P+ J
         break;
      case '*':
         result = x * y;- I9 r5 o1 z5 D. }% W: p2 [
         break;: \9 \% z5 c4 {/ j8 J- I$ k
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;. G; t& |6 i5 ~4 X( t  `3 ^' Z
         }
         else
         {
               result = x / y;5 L/ F4 _; f8 T! x6 Z
               break;' ?8 R3 {& y2 z5 d* ?
         }+ X7 X3 x! H' ~9 r; _/ T
   default: 1 }+ [  _3 d5 |( _: L, A
         printf("Bad Input.\n"); , G) E. _: c% u2 y& S$ B* y
         return 0;7 c1 c6 H$ L  b# d8 d3 ^# b
}
return result;
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/6 J2 L6 B; ~# C. o$ c
{$ p, C, H, O6 R2 e3 o) b
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;' W8 N6 R" Y" @
char c;0 a) F$ Q8 q" ?) I% U
char buf[16];0 T, c0 O; k& R6 F- g' Q9 h" o! D
int i=0;

InitStack(optr); /*用于寄存运算符*/4 J, `$ N: u1 n; a
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
1 y, V. x" W4 c; p3 a/ s
printf("Enter your expression:");
      7 Y+ q+ H7 P/ c" Y1 z
opr_in.ch='#';' q0 j5 d7 ^3 f$ Y9 L/ u. U
Push(optr,opr_in); /*'#'入栈*/9 w+ U- {/ t; A+ V4 p0 F
GetTop(optr,opr_top);
c=getchar();* `) ~" X8 p; z2 O8 t7 ^
while(c!='='||opr_top.ch!='#')
{4 B1 s2 H9 n; w5 A
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;' E' l& P/ r; A) V
         i++;" H* e+ W9 B( Z+ ]
         c=getchar();$ y! g. B% f" l, C0 `$ w
      }6 u! \. h+ |- K* F5 ]
      else /*是运算符*/7 y5 c; P* U7 c$ q
      {$ S0 O" D! i9 Q) |# _" q
         buf='\0';: I) B! Z9 ]& }" v5 J
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
, n: N  @  A& P* s- W          {  u2 X1 \  F& I/ G
               opn_in.data=(float)atof(buf);
& I' ?$ F/ k* f) F7 M                Push(opnd,opn_in);
7 z- ^+ z2 V1 r: j+ a5 ^) C                printf("opnd入栈:[%f]\n",opn_in.data);
# v6 ?& d1 q% s' ^% e                i=0;7 d. j* \3 L, \7 n1 t
               memset(buf,0,sizeof(buf));0 F$ ?# y( l3 C( S9 l3 a1 c2 P: S0 X
         }
& B- P+ v# J1 e9 Q" y- W' E          opr_in.ch=c;
: \4 e( l; ]" e+ t          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
0 ~* S# B& X6 p2 y4 p1 N9 Z          {6 J$ w$ N4 s  h
            case '<': /*优先级小于栈顶结点,则运算符入栈*/3 ^: l5 I. ?; D) g, @4 D' h
                  Push(optr,opr_in);, J) v2 V- T) X4 t! y  p
                  printf("optr入栈:[%c]\n",opr_in.ch);
0 d- c/ U# ~$ z3 f8 R                   c=getchar();
0 `* a3 ^1 S3 N# P                   break;: N9 h; c  G  _; [2 a
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/$ N4 F  x$ H' H/ b) q$ ~; Z5 {( w( ]
                  Pop(optr,e);
8 C3 X3 B: d7 A" C4 u5 w                   printf("optr出栈:去掉括号\n");
. S1 k) o) Q) b& O2 u* p                   c=getchar();7 f9 p( X% a/ C. X# M
                  break;
$ {3 |8 s9 r& a" U             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
5 T" l8 h9 g0 ^( f                   Pop(optr,opr_t);5 t! H5 C/ K. \) \, F. `
                  printf("optr出栈:[%c]\n",opr_t.ch);
; e- b. O( U0 d3 Z# ~% w6 P7 j                   if(Pop(opnd,b)<0)/ o# F1 w) @8 K$ }" v& f
                  {
3 C1 u$ p2 j% ^: [  Z% e                      printf("Bad Input!\n");
. x( s  }2 k  B3 Q9 N8 X' [                      fflush(stdin);
* E- R2 i; P" n$ K% ]! p/ R                      return -1;
- w* z# ?8 a4 Q7 [# m) J* }                   }, p. X' }6 D$ `8 j
                  printf("opnd出栈:[%f]\n",b.data);! h0 }/ h- K! c- g7 Q
                  if(Pop(opnd,a)<0)
3 T9 _  A& b- ^7 D                   {
6 P: p/ l0 R# ]1 l                      printf("Bad Input!\n");8 E: m) c1 b, P" a; p3 f( G6 u
                     fflush(stdin);5 N' S" w6 X' C
                     return -1;
0 `4 |4 G7 s1 D+ S, y7 u                   }% p& V3 @+ d3 F) Y6 C& A3 t3 ]
                  printf("opnd出栈:[%f]\n",a.data);
  h+ y; a% Y) w3 x# E  ?                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/) v% m" W/ T2 i/ \0 R' G
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
4 b* [: l6 Z! ^7 B$ R  X                   printf("结果入栈:[%f]\n",opn_tmp.data);
* H# K8 _! ^: F5 K! E8 z                   break;3 K( `, j0 j; _2 p$ r
         }
# g/ L* h! c- R% B       }
9 V6 W0 z  O3 b) w) p5 A0 z& j       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             8 R# J' H2 K1 `( B# _( w
}
# q$ R( F# {1 }5 |! U. } GetTop(opnd,opn_tmp);
: e$ n+ A; F9 u DestroyStack(optr);' Z5 W/ w% y7 d' w/ E7 }8 O
DestroyStack(opnd);1 ^9 G& x# N+ ?2 w6 L4 D+ p
return opn_tmp.data;
6 b- C/ `1 W, U}# A/ y* O+ t& f
8 v8 B& ~9 I' W) I) E! m
char *killzero(char *res,float result)
! ]0 q9 J  e1 Q4 r! ]% }{7 [. N3 G& `. i. t
int i;; ~. R* l3 W% G

; X; N8 Y6 ]* G: `; z9 } sprintf(res,"%f",result);
. B( B9 H: b( p+ N/ V9 ^ i=(int)strlen(res)-1;
/ v% q6 x. g: p' W8 M( h$ z% P  l while(i&&res=='0')
% G: W# @9 A2 q. L# ] {3 P6 X9 a9 j% H8 Y: k
      res='\0';
$ H$ O! u  U, u" u* i       i--;
3 a# C; s5 d3 @0 o$ M' n }
( b% x; E. G3 C9 h3 n# m9 r/ y. D if(res=='.')% j/ m$ _! i% A
      res='\0';3 M9 q1 o; u: X6 [. }+ M) M
return res;
2 J* X# Q- }, d7 p! h7 P}
1 F" M* a) D, @  U
$ }3 l4 l* E- S4 W' ^6 k! R7 }" Eint main()7 q' H! i0 M, H0 r2 w
{# g- C& P- f6 N5 G; _) }7 x- S
char ch;
( q" }5 w/ H  F& w0 N! N+ [ char res[64];
# i- ]) h* d8 q4 g0 z2 I& L' Y, ?$ v8 d float result;
! [7 N6 W) A  b/ k. b while(1)
) ]" O5 S; x% r. c8 \8 ~5 h {' K3 G. p; U$ M9 F# a/ `: P
      result=compute();9 l8 o) k, A) m, F* |
      printf("\nThe result is:%s\n",killzero(res,result));
! u9 s/ ?# A! v3 ~9 ]% G- O       printf("Do you want to continue(y/n)?:") ;
$ w' l: u0 o" A       ch=getch();/ ]7 ~/ ^* C% [' Q) V$ d; l
      putchar(ch);
- C% i0 }) l6 [7 s4 v  ^       if(ch=='n'||ch=='N')
; g6 R$ |; `- {7 ?* N* Q          break;
9 e- `& M* R/ N% k) G4 V9 t       else; b# I: R( P0 {$ ?
         system("cls");
4 q, }; V# [6 y, A7 Y8 ^6 L" Y }
) z& M; ~) I2 w* z9 q$ A( q2 L return 0;
, s! |2 {& P/ j) @- z2 a}
2 k% m. t& f) F# T: h% |4 w0 m
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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