C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>, l: |) M$ g5 j7 }
#include <stdlib.h>* l1 p* J% T- G+ e* E) ~
#include <string.h>7 n9 ]) R* n/ C, k
#include <conio.h>* x) j1 }$ j* x/ m1 Z0 w# n& L
#include <malloc.h>4 [' `4 w8 Y2 ?4 K

#define STACK_SIZE 100
#define APPEND_SIZE 104 L- S" E$ {8 t4 o. Z
* R5 b8 F$ d9 L- ?) Y0 Y- L& x6 T
struct SNode{
float data; /*存放操作数或者计算结果*/0 ~  B( D$ U* K
char ch; /*存放运算符*/
};. X9 {2 D1 J' {5 G

struct Stack{
SNode *top;
SNode *base;
int size;
};5 _) y6 y) a) C2 D1 B. V

/*栈操作函数*/# p) ^$ R. w0 }* f* I7 Z- ?0 `
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压入栈*/. G: r* P! [( V' t
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/& \* }) s& w5 d( B
6 @) l7 b  d, X  C: c* y" r3 F- U
/*表达式计算器相关函数*/4 I! P; r4 M7 @
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/, G. \5 ~9 X1 z: T3 F. r
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/, t1 x0 l- ~, t) P
float compute(); /*表达式结算器主函数*/% |4 R1 l& _' P0 i1 l6 R+ Y
char *killzero(float result); /*去掉结果后面的0*/ 2 n  P2 B* y" s- T$ p7 O2 x% s- d

int InitStack(Stack &S); |; X! ]) E. c6 \- `
{1 P6 m0 _& e9 b
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;6 ~% c1 x( @  S+ z" j$ p4 r
}
S.top=S.base;8 }. u' i  g; Y
S.size=STACK_SIZE;
return 0;
}" G- T- W2 ~& L& w' F5 n
7 E0 ^& g' o* ]1 @6 H* S
int DestroyStack(Stack &S)7 T6 @  L5 K& M1 q, {# V
{4 w- L& M9 v& `, b
free(S.base);4 C# w( D# x# ?8 H: H
return 0;
}
5 g$ o" T4 \4 k& d9 D
int ClearStack(Stack &S)  D9 t, c" o& R' L/ l  f0 @
{5 t! ?, c$ \: ]6 J- D6 k. }
S.top=S.base;1 }, ~, `( C% ], D% e3 V
return 0;
}

int GetTop(Stack S,SNode &e)
{2 L& q+ t/ b& F6 o- D( B
if(S.top==S.base)
{0 @  K2 y7 G* ]5 x. M# W; p
      printf("栈以为空!");
      return -1;9 c' K, F- t) f
}
e=*(S.top-1);
return 0;" e$ \( D4 m: L8 v) i3 C5 v/ u( X
}
% w/ ^& F9 o6 o9 z
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)8 d# k: A9 a% @  {) y8 U* c2 O) H$ S& F
{  a) |' U; \6 q( D5 d; |
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));# l" @1 F+ I0 m
      if(S.base==NULL)' F! b" J1 D, |6 R
      {$ Q: C, |) W' c( O
         printf("动态分配内存失败!");# Y7 m& n  [" h  `1 U: j2 W
         return -1;. w  K7 C' L6 w0 x
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}  @9 ?; G. m! i- J7 ~" k# N- T7 V; E% _
*S.top=e;: j% ]' L# K* H$ a5 j- d" l" Y
S.top++;
return 0;
}
  U* R7 @1 p/ V  r" R
int Pop(Stack &S,SNode &e)0 p7 r' d3 S3 z) H! d- l9 L
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;4 j$ N  Q7 _& A, C
}1 d, l( g, F6 h
e=*(S.top-1);5 T$ r* `( `+ ]! }& T; j' R/ ?; `
S.top--;. j$ Z# f1 f, Q) i
return 0;
}; S+ w* L2 A9 X+ V! h

char get_precede(char s,char c)
{
switch(s). \! H+ u$ N1 H
{
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')0 m, _) v, w: x/ I
               return '<';! _* {4 ?. h% [1 e
         else if(c=='('). a- L, j" j7 y$ a! `: U. L; b
               return '<';
         else if(c==')')9 s% O1 W+ U/ O: z& q3 k& h
               return '>';3 D) {: B% S) g  m9 M- H! z
         else , B6 u, x5 M! d. T" r
               return '>';' N7 x$ ]1 D) N5 ^: ]* L
      case '*':3 A1 T/ Z+ c. J* N# z
      case '/':0 b0 o' [& ]/ k) \7 O/ B7 t
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')+ ?1 o) }) Z1 S9 }/ V
               return '>';
         else if(c=='(')" \9 j8 I$ S, ?
               return '<';
         else if(c==')')
               return '>';
         else8 t, u, ~8 E: h# X  [+ ~! q, t0 [
               return '>';
      case '(':; W( K) r% i+ ^. Z2 P2 @/ O9 \5 x
         if(c=='+'||c=='-')
               return '<';$ W. ^) |4 F  ~- N% n& k. Q: |. I0 f- b4 n
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')# |6 w' k- P" @3 U9 a0 k" p9 |
               return '<';
         else if(c==')')
               return '=';
         else/ U5 f1 v6 X: f( |- j7 @
               return 'E';
      case ')':+ q% S$ Y4 y# P/ F4 a$ |2 a- x4 _
         if(c=='+'||c=='-')" c( {" Y0 e# K3 o
               return '>';4 _7 I! c& ]+ {0 C3 N
         else if(c=='*'||c=='/')  A2 A: E0 Y* K
               return '>';, A6 i% ^9 ^) c+ T$ S( c2 w
         else if(c=='(')6 G3 }9 N8 r7 l. R3 K
               return 'E';
         else if(c==')')
               return '>';4 S4 u! J) m: K  t
         else' `7 `- I( z6 p" i7 ]1 D
               return '>';
      case '#':0 F3 @2 `% l& ~8 l* X' l
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')% i* k1 ]/ C7 ?! V' B
               return 'E';; V; c# C! D# {1 B9 F# x
         else
               return '=';
      default:" X5 C2 s% ?2 M& p3 N; G8 J
         break;% ]8 w7 E# p" O- X% D/ N  W
}
return 0; / J) D6 i! b' K9 V, d
}, ^# G4 @+ V' I* V
. `3 i2 _/ }  R0 R
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else ( x* V, [* a! T: j  {- _
      return 1;  t7 J4 ?2 A* [5 P
}' c+ W0 R8 _- q7 _/ a' W* U
% S9 L! w6 T8 U/ h' W1 M5 e
float operate(float x, char opr, float y)
{, w; C; w' H! A+ H/ q. j
float result;
switch (opr)
{
      case '+': ( w5 G) A7 \1 z+ `  T. b* ^
         result = x + y;
         break;( _: u, p8 X6 C: o" k
      case '-': 2 O  b/ G" t- N& T- @2 w4 A
         result = x - y;: T5 {+ y0 @  @; {4 ~
         break;
      case '*':   c' T& S9 J; k8 _! s$ u
         result = x * y;
         break;
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;2 X- ?( Y% [" n5 i8 p/ Q( k5 s7 T
         }. k+ q' v1 a1 \4 r
         else, A! e* ^" }8 z9 u4 T  V9 {
         {
               result = x / y;2 ~# n7 p+ h0 U
               break;
         }# |# I; q/ O$ A6 t, _6 x
   default: : @$ d- F6 j/ f+ [9 q
         printf("Bad Input.\n"); 1 G* v5 V4 A, X: k, A
         return 0;% d, i, {) H* l
}
return result;
}
0 l; j2 q1 ?. i# X% j4 z1 o( Z
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;0 G8 j) ^) L* r8 e9 m7 U; O
char c;, v; P  {. c, N5 W, {3 v
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/; _; ~& N- s- e( Y
memset(buf,0,sizeof(buf));$ }' A6 T# P6 o& X
4 ^; @$ G& z. t6 w% b
printf("Enter your expression:");
      1 K7 T. X8 ?7 g1 x. b
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/1 R% A: s; v' C3 `
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')& R3 E0 S! R7 w( @$ H/ `0 [
{) Q8 R% ^/ _# v
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;9 H8 A3 |! s& P  R4 M
         i++;; w! c- u; s" c6 F5 w( q
         c=getchar();
4 B; U/ v9 X  b5 P& n7 H( F3 J( @- h       }2 `! f1 o; R- k/ h! m( B1 `
      else /*是运算符*/
8 \3 D$ n' ~; D1 E5 I       {
$ a8 k5 l8 O2 H( n; I          buf='\0';1 X; d0 Q9 r/ |7 z
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
9 {$ E4 {4 x: a( `          {
! ?" M+ m1 n, e2 S! p                opn_in.data=(float)atof(buf);: U& K  L# Z: M5 x5 k3 r# k( g6 n
               Push(opnd,opn_in);
, ^4 \) E  Y5 N  ]                printf("opnd入栈:[%f]\n",opn_in.data);/ Y- g/ w9 j" h: @2 D, A
               i=0;' ^" z( d! y9 v7 P
               memset(buf,0,sizeof(buf));2 A) }" Y1 f. V$ `! X: m, p
         }" m! M7 z6 {) q  n2 @
         opr_in.ch=c;
' W6 I+ x2 S; F* l' K3 a6 a. V          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
5 }0 X/ S- b1 l) I          {- Z4 X* @& H- d, ^9 |( x
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
* J! e! U, n  A                   Push(optr,opr_in);& H) y8 q. r: p2 [9 |$ C9 m- ~+ u' `
                  printf("optr入栈:[%c]\n",opr_in.ch);
' k! @6 n& v( F5 |                   c=getchar();
. D. y  E' u1 t+ j9 U- B                   break;; \8 \: j) s; d2 h- K" a. w- r
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
* N0 U) [5 J  X% X                   Pop(optr,e);
1 R2 }; X- B/ Q* E& w+ c. ?$ R( C                   printf("optr出栈:去掉括号\n");
$ p8 Q. c0 K+ e  ^                   c=getchar();) S/ `' S# z: Q
                  break;8 V* f0 w  l0 ?
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/: l6 s! E2 M  Y) l
                  Pop(optr,opr_t);
. l2 v  T! c  ^! e/ H2 X$ z5 ]                   printf("optr出栈:[%c]\n",opr_t.ch);( W8 q# P% ^1 b- h1 \
                  if(Pop(opnd,b)<0)
" v. e/ y! o1 S                   {
3 v* Z( `& _$ E; c                      printf("Bad Input!\n");/ {$ F7 G7 E& |7 ?* |: _9 @" s) x
                     fflush(stdin);
% z8 i3 h9 m4 R, U& ]5 t8 _                      return -1;
- i- V( Y1 r" u) w( I* a                   }
' |3 L" q, G5 z; \1 ]8 x$ A                   printf("opnd出栈:[%f]\n",b.data);
& e* x% c. u3 y/ S                   if(Pop(opnd,a)<0)6 Q- a2 n" Q/ O0 I& Y
                  {4 X, H" B. a: S7 Q2 x
                     printf("Bad Input!\n");
                     fflush(stdin);2 D" Z: |/ u2 j. S6 O4 F% T
                     return -1;5 I% l- o, h* }
                  }* y* u. _( b) q/ d/ k1 ~
                  printf("opnd出栈:[%f]\n",a.data);
( a% x4 W& G6 G& y/ T                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
2 N( h, H+ J+ e, C% n  R+ N                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
3 s4 W# m$ |/ r! y9 l% P                   printf("结果入栈:[%f]\n",opn_tmp.data);. q  G4 ^2 v' o9 K3 \( W' x
                  break;% j/ _* C% D4 @+ @: v/ z- I
         }0 ^1 B/ s4 X. r$ w( X  o
      }
& |* W7 C* I5 C& X7 p" E       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             6 E2 \7 Q5 j& m0 C& b' R! I  ]! ]
}
: W1 A1 T/ w3 Y8 d  f GetTop(opnd,opn_tmp);
5 p9 |, n! I! @ DestroyStack(optr);
! `$ T1 r- X% u) \ DestroyStack(opnd);
! [* M& ~' A/ z return opn_tmp.data;
, ]+ u& A% e- i8 z! I& e8 S8 K}4 e# L. V( w# y

6 o! r, ]  O2 O- zchar *killzero(char *res,float result)$ X7 A1 `  ]- t0 m% J
{" c5 V; i0 C7 ]6 W" @6 M' P( t/ T
int i;
) n- U. F% p0 T7 b8 w; K
( O% [1 |- @; `4 d" M' b$ w2 w) j sprintf(res,"%f",result);0 c  o* w7 I1 u% k
i=(int)strlen(res)-1;
0 E' u& ]4 S' h  ^1 i! e while(i&&res=='0')
  g; W1 c: ^  a5 h# t {( q& v+ ?; u! s2 H4 x6 e
      res='\0';! h" S+ t7 K( C( g( t2 f) x
      i--;
5 e" S/ @" r" S' I9 { }
/ N9 [  F, _, n2 b if(res=='.')
, [! l, _. ]; X& U5 x* B7 [9 c       res='\0';" A+ Y' d) D6 J. ?
return res;$ c0 D, j3 j: ~; g5 H* f
}* p0 A0 q( h0 c- ~5 D# x7 @& n

% j/ u. n* m( x' b& y2 kint main()! {5 O6 r- }3 {$ }3 Z
{2 F+ g4 q) C# x. m, P! F3 u. l
char ch;8 N# H7 t( _( }4 q; i
char res[64];$ v8 g) g) p' q0 P5 L
float result;6 Q' L% Z+ Y; ?% r. ]: z; Q$ W
while(1)
% c1 Q# O& e) b) Y. C {
3 x4 c. M  `, O3 a       result=compute();
* G, I; E/ M, `. p, _; O       printf("\nThe result is:%s\n",killzero(res,result));
/ a" ^  V+ j$ ^: z       printf("Do you want to continue(y/n)?:") ;
9 ?  x6 r4 |* ?- m1 |       ch=getch();
- T+ d3 m' V0 b' t1 Q; m       putchar(ch);
* S. ^7 R1 P0 g2 s       if(ch=='n'||ch=='N')
. _0 p0 ]- ?, q" Y/ W( I+ K/ r          break;
( G9 z- I% z8 @& a# r3 j       else
  n  D7 B- O' d8 O5 [7 ?          system("cls");
+ L8 T2 p% {! J5 ~9 g  |) B) ?. h2 A }6 }8 e& S- L* a; ?0 _
return 0;
7 a% b# \+ y1 F! v6 o}

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

返回列表

C语言表达式计算器

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

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