C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>5 N# U9 p0 n' S7 q3 b/ p
#include <stdlib.h>, j: N. X* Q+ J
#include <string.h>
#include <conio.h>
#include <malloc.h>
0 ~+ b, \+ |& V6 U
#define STACK_SIZE 100: _8 A# c. |, X; [3 {, c& W3 B
#define APPEND_SIZE 10
1 H4 z( P( x( y0 C7 a, F8 @
struct SNode{$ `$ A; ^/ Y" _/ g# `6 O
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};7 X* Y! h9 m$ X& u' t

struct Stack{
SNode *top;4 ~: Z5 ?( l1 r/ r: l2 N
SNode *base;
int size;
};

/*栈操作函数*/* H- I0 c3 Q4 i! L8 o& ^
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/% P/ d. a" Y) g. O! Q( I! W3 b

/*表达式计算器相关函数*/
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计算后的结果*/* D4 @1 P4 o" }  N3 e: K
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 9 i8 d( a5 b, C* y
1 [, U' @/ y' G# {6 X8 c1 q
int InitStack(Stack &S)% |8 i# o0 {$ P* n, ~
{8 h" ^0 c, w$ @6 o2 J. I0 ~6 ^
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)0 ^% d  U& X: t
{
      printf("动态分配内存失败!");6 \8 p& h0 W. ^  a- d
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;, W. X4 |2 q3 t; \! ?! l
}5 k7 I0 Y& s% \2 V0 j0 V

int DestroyStack(Stack &S)
{
free(S.base);, h2 Y$ B0 z1 a. ?- A0 F
return 0;# T. m' `/ X: ]
}

int ClearStack(Stack &S)& W$ z. r: m' m: W" E+ L( |$ Z# N
{
S.top=S.base;' i" N  u7 b- ]2 \5 }1 Q6 o- ?$ v
return 0;
}$ K( z, F2 J* @3 f

int GetTop(Stack S,SNode &e)( o) @6 ~- J# i& ~% [: a
{
if(S.top==S.base)0 w$ n$ e: \! t% `5 \
{3 z' k+ L  b) D, F4 @
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);' g( V8 R2 O2 N$ `* k6 q% W
return 0;" G! b8 {0 h8 Q( |' O/ \
}- b' `! s8 E# [5 D5 @

int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)) G; P2 \; A  b: B% ~
{- C, A. L: K/ W$ J
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)3 H( D3 |6 E1 ]
      {
         printf("动态分配内存失败!");3 D: Y- L! n2 D/ a
         return -1;/ f* Z. }& u; w0 _
      }3 W: ?: `& [7 ?; ?7 C3 W
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}! B+ s1 n/ F2 \5 X/ D( [
*S.top=e;
S.top++;
return 0;1 a7 Y8 |9 R5 r
}* _- z3 Y! y( d. d, S* I- Y6 {4 Y
5 T2 E, L7 }' e* r5 R: A" _! \
int Pop(Stack &S,SNode &e)7 V" B6 z9 n( O) e
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;; s' x6 ^: A" ^0 u& T8 H
}. ^4 B6 q7 K) p  l
e=*(S.top-1);" |  q8 W3 {4 D; h0 d3 m
S.top--;% N9 O- U( K$ b1 Z! F: Q
return 0;5 _# Z. y5 }$ i: J3 R  E
}
4 o2 i9 Q( g) H$ E  i5 M
char get_precede(char s,char c)6 x: {: W: M& n( u4 y; v) D
{
switch(s): A$ @7 ]* A8 j- Q5 t5 x
{% E3 }, N3 {, H
      case '+':                . `4 N9 j/ M) l) s
      case '-':
         if(c=='+'||c=='-')
               return '>';6 t' e2 z/ F  Y/ |
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')* k5 G4 A3 e: m; s
               return '<';
         else if(c==')')$ h5 x/ }! z( @* h- u
               return '>';( B% O, w/ h1 r4 Y
         else
               return '>';: \0 V. ]# D; U" U- ]
      case '*':
      case '/':$ E8 @8 O9 |7 w# A. ]+ U
         if(c=='+'||c=='-')" t7 g+ I$ }; u* }( @
               return '>';& C5 D( h% I. C( p: p% r% }
         else if(c=='*'||c=='/')) Y: G' b6 k2 _
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';) Q& E" C8 x: `
         else
               return '>';
      case '(':6 Z# x' q" ]( ]  @0 l, M& G  e
         if(c=='+'||c=='-')0 X; ~* h" O  N6 d
               return '<';/ e8 D; z$ l- F- h4 g
         else if(c=='*'||c=='/')  B/ ~. G. x. c- `& J) J  f1 O
               return '<';) Q+ G: r0 }; k6 [2 ?
         else if(c=='(')
               return '<';
         else if(c==')')4 h5 g( b; d: w; A# p) C( Z0 v
               return '=';
         else
               return 'E';2 v8 H0 q0 I, f
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/'); A* `. C3 Y# s: ~- p
               return '>';) w2 M9 |1 U. R$ n1 n
         else if(c=='(')
               return 'E';
         else if(c==')')6 t' H2 L# F, _' _
               return '>';% A: ~2 o$ J# G+ A: D' E2 l" v% Z, i
         else
               return '>';2 c6 F, E+ y& F# [# \
      case '#':
         if(c=='+'||c=='-')
               return '<';7 }7 \: M* n9 P: P5 W7 Y
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';$ o0 q/ f0 s6 t& _- y6 |
         else if(c==')'): z8 r# P0 ^7 J( \/ F0 s
               return 'E';$ z. H5 o- Y5 q6 K
         else1 e! i  w$ q+ g, N6 ]+ @' W
               return '=';, Q9 J9 E' i/ u+ Y, T* j
      default:% k" ^9 Y; E* I  J, i# ~
         break;
}8 E5 ^/ q; A2 I5 U
return 0; , X. K6 F: e9 e
}( G/ t, J5 t0 v+ I5 M4 R

int isOpr(char c)( {0 f( e5 Q- z2 r! s
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;2 N1 W8 H( Z9 y  l$ l
}

float operate(float x, char opr, float y)
{
float result;. m' c3 o8 W4 r7 f8 N* D8 Z
switch (opr)$ I2 x+ R# V: D0 }# M( @7 Z0 I
{
      case '+':
         result = x + y;
         break;
      case '-': " p. x# w, H  X5 U9 ?& E: {
         result = x - y;
         break;! g% J" H$ p) Q; q2 R9 k( g3 f
      case '*':   p) p( ~; X+ O* p3 Q
         result = x * y;: ?/ O# z4 ~8 ^
         break;7 Z, q8 g+ l8 L1 ?7 B
      case '/':
         if (y == 0)* B- E4 O3 Q7 I( P7 B
         {: `4 x. a9 _  J4 n( s1 N! b4 ^- I
            printf("Divided by zero!\n");
            return 0;! i. T& f8 _3 _' k* k* |4 V, m
         }
         else
         {
               result = x / y;- r, D% I  T" W% }
               break;
         }
   default: ) d: L# C/ G8 d( e" v; y
         printf("Bad Input.\n");
         return 0;/ a; G; [4 z0 ~% b( R3 g1 }
}
return result;" v6 K5 p9 W0 D- }; }! l
} 0 m7 p& Z1 ?2 K+ A( Q& I

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/9 |0 f9 s$ C  j
{8 E1 C# G- ~, w
Stack optr,opnd;# s7 B/ B  r' Q& {$ D/ ~$ g; ~
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;& }# R+ {5 y; g8 I, Z- N% N
char buf[16];$ U! X: g5 x8 [2 D2 c
int i=0;

InitStack(optr); /*用于寄存运算符*/) _5 r( |7 N. n7 V/ q% P5 w: D
InitStack(opnd); /*用于寄存操作数和计算结果*// Q, z! E9 p( x$ q4 Z6 S7 f7 Q
memset(buf,0,sizeof(buf));

printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')# y9 U! x8 L- y6 [# S8 Q8 ?) ]) F
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/! W4 [/ I& `4 z2 v" B+ Y" P, {
      {% W+ S# X- ]/ [
         buf=c;
: A* D: E- E+ ?! W7 y          i++;
# P. w7 A& d7 j' N5 l          c=getchar();7 x( M: e1 o2 f) |6 U, g  u9 p
      }
) U* w, y8 [! M: z# {       else /*是运算符*/% B) g1 y# A2 V3 y" \
      {' V. v( T, D1 q2 |2 a! f
         buf='\0';4 r9 S2 Q5 w# m( Y) l; k
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/0 S9 m# k+ t* H) ?. t
         {  j+ c, R9 F; A# e# b: w
               opn_in.data=(float)atof(buf);3 w) C: K' I3 p; x; ^8 o, |
               Push(opnd,opn_in);# H; \. f1 J( u+ C6 y
               printf("opnd入栈:[%f]\n",opn_in.data);
2 T; E5 l0 m2 {                i=0;
& y# `! N& m, _9 z- T5 ?3 A, l                memset(buf,0,sizeof(buf));) k- Q% ^: N' x( Y4 R
         }
' b7 D8 J! D; V+ ?, z( u8 z0 Q* w          opr_in.ch=c;
% l; n1 K) T+ Q. O, i1 C8 N& ?          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
% |( U: a9 \+ t3 n          {
7 u3 q/ H2 `) ~; x             case '<': /*优先级小于栈顶结点,则运算符入栈*/$ y; n2 l+ g4 [  {! E& T1 D
                  Push(optr,opr_in);
6 G- o( ]- [6 ^, ]                   printf("optr入栈:[%c]\n",opr_in.ch);- c; r! ]# F0 ^" `
                  c=getchar();
% |* a& Q, L7 e1 p7 \, C                   break;
; ^+ f7 R. P0 f0 k+ o( X' u             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/0 L( l4 E  V. o0 {9 h
                  Pop(optr,e);
! W" m8 q& P4 N3 g                   printf("optr出栈:去掉括号\n");
9 B1 w$ X7 q. n8 Z9 ]                   c=getchar();1 U. j2 [  W6 l( i! V) a
                  break;& T+ L2 C6 G# I" [) {- h. D
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/  K1 y; Q8 S' G% u5 N1 Z
                  Pop(optr,opr_t);- C* r$ a; ~2 D0 [* h- f( h& Y# n( I
                  printf("optr出栈:[%c]\n",opr_t.ch);1 ~  G% B) j) n: Q
                  if(Pop(opnd,b)<0)
/ _& k% W1 ^8 ^, L3 n                   {' e2 h% L4 B0 K5 o6 }
                     printf("Bad Input!\n");
8 Z9 D  Y0 P3 {                      fflush(stdin);
6 _2 M6 [/ n4 v/ p, D) I" d( S                      return -1;  ^0 E  Q+ S, r" E* }5 m
                  }
5 g3 T# N6 K$ J2 D& Q& |                   printf("opnd出栈:[%f]\n",b.data);
* h4 K8 V; a- W/ L8 G* Q                   if(Pop(opnd,a)<0)
: f9 w0 |9 s2 B. P* V6 H& D                   {, |" V8 J& b, n( g- G$ U( |5 i# A
                     printf("Bad Input!\n");8 {( ]- i7 r5 w9 I
                     fflush(stdin);0 g& e" S) M, s& q7 N  C7 H
                     return -1;
$ S; N# i0 @! m                   }1 @8 C: {/ _' H5 E# R) f
                  printf("opnd出栈:[%f]\n",a.data);$ n- j+ O. ?1 @# M- M: ?
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*// B! L1 [! c8 d4 o1 T0 u2 n
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/: o$ z: s, C/ O; g( Q5 j2 q4 Y
                  printf("结果入栈:[%f]\n",opn_tmp.data);) O5 i5 A1 O* f6 Z0 {
                  break;  c7 E) X/ x8 b
         }
/ _$ ]2 i( K3 `; Q$ D, ~       }4 ?) U0 c; n0 g
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ( X2 Y5 A) r  Z* ?- G
}- p  E# W6 \2 Y1 R  U8 s* t
GetTop(opnd,opn_tmp);
0 @/ d: a+ P$ |0 }6 {7 Q: }1 {1 [ DestroyStack(optr);$ c8 V7 x+ _' D! j
DestroyStack(opnd);
! n3 S" N4 @/ [: @: l1 { return opn_tmp.data;$ |% k! v. F; d$ S
}
2 d" B$ l  @0 M& M5 _7 D& R4 P
% @3 J1 A$ a0 ~6 z6 k! fchar *killzero(char *res,float result)0 S9 D0 U# ]( Q5 ?
{
0 |. `% s2 R1 x int i;
" y" C# |9 z8 t9 P7 h) l; n8 Z2 P( S8 `/ J# U; y  R
sprintf(res,"%f",result);
7 z: x- k) c6 c i=(int)strlen(res)-1;
1 \& F; f5 L* p5 J) y* X3 m8 j while(i&&res=='0')
7 @* ^) }3 F- W  V {
5 ?/ n8 A/ U* d       res='\0';2 D& f* S( ^# j, Z2 l
      i--;
0 u/ E# }$ N4 Y }0 h) l1 O7 T7 I  l( t- v5 Q  B. X+ s
if(res=='.')# P+ f; Y+ M9 d# J) G7 j. w7 y3 y
      res='\0';& ~2 r" l3 R$ O: b( t: r
return res;
4 \# _: R# i* }$ `6 r}

/ t7 k0 r0 X9 _0 L% c: nint main(). m0 U$ Y  A0 R3 G$ L6 `1 ^. C4 a
{
) ^. l) r0 {/ X: G) ?, u char ch;
& o, o0 R5 |2 ^4 e8 n6 B char res[64];9 Y- d' r7 I/ L$ ]- A
float result;
, p# r1 w# V% i  S3 i" j7 Z while(1)
+ f7 e: H  d% ~' F {4 }) m! T2 e' u7 J9 U
      result=compute();
* C! A- f$ a! D$ m' l1 y3 [4 ]       printf("\nThe result is:%s\n",killzero(res,result));
3 v5 y- v5 U' G       printf("Do you want to continue(y/n)?:") ;
9 U: H! H$ h# s9 B' i4 {       ch=getch();
9 ^3 k0 [6 x1 s       putchar(ch);
* w% k$ W: V# `" F7 u- l       if(ch=='n'||ch=='N')
3 `7 j7 X3 Z! Z, a) g& U+ E          break;
3 p2 r2 o, e- n; @, T. V; w6 c       else& y/ N; ~& I3 L. F! M# d' I' }
         system("cls");
' s/ r! Q! r! Z$ w& v% u% E6 D. y }) P) {7 V% [0 n! f
return 0;
, V) \& p  L  ]  a}

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

返回列表

C语言表达式计算器

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

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