C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/; ^6 Y8 l, D3 j1 x
#include <stdio.h>+ O: S% s  M- ?" H( W+ k
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};
5 T+ Q  W5 Z# y  p8 Y: i( F
struct Stack{% I9 Q$ {+ H5 d3 {, n( {! o5 _
SNode *top;
SNode *base;+ e+ L. N$ \6 z( h; e' w8 p1 ?  v. M
int size;
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/( g' @& h/ b0 f1 c7 M
int DestroyStack(Stack &S); /*销毁栈*/0 i1 i3 i% q, S# O. v! @1 b& f( t
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/4 `2 A" K7 `' U+ F* y  P9 P
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
, u5 x( i, c5 X& Z) N) o
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/2 d# B! y6 A! Y1 B! A- d
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/+ P0 z# R1 H4 D. ]7 @' _1 p
char *killzero(float result); /*去掉结果后面的0*/ 3 \" }. w3 \0 E9 A! T5 m1 O# X& l( n

int InitStack(Stack &S): W: R. v8 U* A/ _( B
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)! p* \+ i/ T- W: I% R+ c9 J
{
      printf("动态分配内存失败!");
      return -1;3 L* E/ v& i, k5 H' w
}# c0 f; @  K4 z- k, \5 G- ]
S.top=S.base;
S.size=STACK_SIZE;0 b- n' {- J1 n" j2 {
return 0;
}

int DestroyStack(Stack &S)
{
free(S.base);
return 0;( T0 L1 l% S9 G2 O# J" w- w. U
}
3 C$ u& z4 G, g/ ~+ V5 }
int ClearStack(Stack &S); T" W  O! u& A/ k- h* h! @
{- k9 K0 g: e" A' ^- ?, G, v
S.top=S.base;$ v5 Z: V1 m" Y) E7 c7 R
return 0;
}% ~5 M9 [: i; r, x6 w

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)' t" m# x' g6 E7 _0 w
{
      printf("栈以为空!");
      return -1;  z! a6 c4 ?4 w0 Z1 e) t/ G7 u' k
}
e=*(S.top-1);
return 0;
}- ~% F! `) w* v/ o' [" r  i

int Push(Stack &S,SNode e)0 h# [) v: @! u& E. {& c; K, |, M
{  q* g2 v: v  u0 q! ?
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {# }# l# j8 _/ W( W: m9 y# a+ ]: c
         printf("动态分配内存失败!");/ V/ C( P6 Y5 N6 ~
         return -1;
      }
      S.top=S.base+S.size;/ P! A& d1 e' Y8 c& N4 [
      S.size+=APPEND_SIZE;
}5 K9 k3 N0 ?3 E1 b. T2 w9 _
*S.top=e;& O7 `: I9 a; _/ M
S.top++;
return 0;+ G) ^" d% z, f8 {
}
( [- Q4 f; j4 {0 x
int Pop(Stack &S,SNode &e): R: i9 z+ l8 d% c
{3 h# T% Y: R1 B/ ^) x4 K( U
if(S.top==S.base); J. ^  _6 D1 k0 B! y' l
{: [( A5 o7 C' T, |/ R& f- ]+ j
      printf("栈为空!");
      return -1;0 v+ L! M- r  A5 d3 M; H# C5 j
}
e=*(S.top-1);
S.top--;" Q2 W  s$ E2 @) j1 s5 g
return 0;
}
' `- O# |+ D# [  ?
char get_precede(char s,char c)
{
switch(s)
{, H  f' T/ T' a7 {" u4 k+ c* l# B2 S
      case '+':                ' Z; H- v& w% W  e1 e
      case '-':
         if(c=='+'||c=='-')8 ]3 l- \5 C" Y5 }
               return '>';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='('), p) e5 V- L. w, X
               return '<';
         else if(c==')')+ Q. H5 b) f0 c" B8 o! r
               return '>';
         else
               return '>';- h: W0 Z+ e/ M
      case '*':
      case '/':
         if(c=='+'||c=='-')4 w' r! a! W  ^+ {5 o% A* g
               return '>';9 J. S. _  s9 [0 E; t
         else if(c=='*'||c=='/'), y* S) S2 ^9 Y
               return '>';
         else if(c=='(')3 }) J3 e: ?/ f( ]( ~5 H
               return '<';
         else if(c==')')
               return '>';: ]/ S8 E4 _# c. j6 k# J( s2 G* m2 S
         else0 v) F) x% M4 V, Y1 y/ g# D5 x, R
               return '>';% I+ `' Q$ ]4 _0 P# m4 H+ t9 L
      case '(':
         if(c=='+'||c=='-')
               return '<';+ W$ t# p1 c$ G4 c$ L. t) a5 L' |
         else if(c=='*'||c=='/')
               return '<';: F) L) C4 y9 ]* r4 I; |1 x
         else if(c=='('): ?! V0 w& W6 J  }9 I! m+ S
               return '<';! C* q5 \$ ~8 f9 d( W5 @/ C8 \
         else if(c==')')
               return '=';8 \* H. x: w- q9 l& I+ f2 i- O
         else* g- ?: Q2 G8 K3 X, F% Y
               return 'E';. `1 u3 X" R# ~1 h/ U. E
      case ')':! D4 s) W7 R+ \/ s9 n% A. [9 }: d
         if(c=='+'||c=='-')
               return '>';5 b2 n9 L( Z, i: a2 d
         else if(c=='*'||c=='/')0 t9 m( e) i( E
               return '>';; N' t, s6 a) N: ~# ^. i
         else if(c=='(')# o* ?% ~7 S  O9 g3 Z
               return 'E';2 _: F; u* I9 o6 |' m
         else if(c==')')
               return '>';
         else. L1 P" e+ B4 F2 T
               return '>';: ^9 c8 i. x2 T) B7 J0 Y
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';7 w: n! g2 Z, P
         else if(c=='('); }5 _& ]. M3 Q% {
               return '<';
         else if(c==')')
               return 'E';
         else7 T3 \$ f6 n' m4 Z! p
               return '=';
      default:
         break;
}& ^/ ^& f7 r2 e" ~2 z
return 0; % ]$ O" g$ X% w" f( B, E# ~9 d0 L
}! ]/ G" @: e$ B$ [2 c* O

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')" Y* Y2 J# S" Z+ {) m: G
      return 0;5 V3 C& d0 X+ N& f
else
      return 1;
}

float operate(float x, char opr, float y)9 m5 l, Z4 p# l/ }+ ]# F( H
{
float result;
switch (opr)4 n- x5 V  B5 B, J! x
{$ S  z: v/ i% \. m/ L  P
      case '+':
         result = x + y;
         break;& V8 P+ R2 z/ Z1 D6 ]: N4 j9 N
      case '-': ' l6 w! C' z: ~1 x
         result = x - y;5 q& W; a/ j4 p2 N3 O
         break;
      case '*': * V: ^8 C+ u4 x/ U; p
         result = x * y;( d. S# U2 O- e9 r* W$ [
         break;
      case '/': ! r: u8 x4 o5 T1 _# ^# [2 v
         if (y == 0)' z  V/ r! M- i: w- J5 U
         {  P! L4 C9 X  C2 ~: D( K
            printf("Divided by zero!\n");- \; M# p8 W' K! A* H) u
            return 0;
         }7 y% L/ K+ \/ s: T0 u0 H. D% U
         else
         {+ v0 l+ j* v; V2 t
               result = x / y;
               break;
         }
   default: + F: `. @( k( h8 m+ A+ S
         printf("Bad Input.\n"); ! M6 d# D! J5 k6 ]
         return 0;
}  }3 \3 r) g0 P; K
return result;
} 6 u7 `% b. @6 s' k2 g5 t! E0 f# @" _
2 U3 M. e* f$ x2 s( U3 x
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/+ m; f! k6 a. T8 Y0 ]
{
Stack optr,opnd;% \; ~) t% u! v" ^/ n1 C2 p
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;9 _2 \! B1 [/ D' A# w) ?0 [
) b9 u# T" O4 [9 a; z6 @, U7 m
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");# w: l; ~  t2 W5 Q

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);) F! q4 \& W- C0 k# j
c=getchar();
while(c!='='||opr_top.ch!='#')$ U3 y# ^- G* L  Z
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/. {, u* l# i7 V6 z
      {0 m  \! H/ d( j; @. ^! b7 }0 K
         buf=c;/ q  o6 s3 z& e# I
         i++;8 F* w/ i% w$ I. d
         c=getchar();
$ K( }0 L, h5 _& R& x9 G5 ~" c       }
& q( Y$ ^9 B' B, T/ w       else /*是运算符*/$ o. S& }1 u- F2 R8 z
      {1 y$ ?4 l- I  q4 F/ I4 y0 n. T
         buf='\0';
/ W; [4 g/ d! _5 n9 e          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/' Q( H5 j& D) r2 G* T+ N% ^
         {
1 C% G- u: g4 S- t$ n                opn_in.data=(float)atof(buf);: O; h$ e% N' ^' c( j0 E$ \
               Push(opnd,opn_in);
, j, u3 P) c& c* ]4 l2 q                printf("opnd入栈:[%f]\n",opn_in.data);
' C6 \9 ]+ S- q* L$ A4 H& Q3 g                i=0;
/ O# _- u7 g" p: G2 U% N                memset(buf,0,sizeof(buf));
' c# I6 ?4 M" ]          }
% t' |- q, O0 S& z/ R          opr_in.ch=c;( c7 |3 a. {4 P) L5 A% I
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
. ~# [  s: B- ]- v: h0 B5 S          {
9 B3 r5 g" i! q1 g- `9 b3 z             case '<': /*优先级小于栈顶结点,则运算符入栈*/! \& l7 t0 b0 r9 G! I# \6 c
                  Push(optr,opr_in);
6 l0 a' B, T$ u% X& w0 W+ d                   printf("optr入栈:[%c]\n",opr_in.ch);
/ w/ Y% f  m" u5 B4 q: A. h                   c=getchar();
8 c3 p1 V# P4 `( s0 B/ A2 K                   break;
( K& K9 i' ]; b# f4 |+ V* T             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
0 v4 A' Y* y: U; s+ P                   Pop(optr,e);7 T  Y4 G# [) a; P8 k) L7 p
                  printf("optr出栈:去掉括号\n");9 n5 c9 [% S6 c0 A  O9 j# i; \
                  c=getchar();
- i& B8 d) N2 p  h  P* s% ]* L3 s                   break;
" O9 W2 p, {% |0 s" t  R! @) \             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
3 n6 a# X( q5 g. r* Z/ O, W* D                   Pop(optr,opr_t);
) V, F4 g9 z5 C; i0 A# ~# s                   printf("optr出栈:[%c]\n",opr_t.ch);& p. e: d% _' d
                  if(Pop(opnd,b)<0)
& o) Z7 V& O2 [: h8 [6 Y                   {1 P5 {# V( c! @
                     printf("Bad Input!\n");# z" q$ v6 K8 r3 @0 l
                     fflush(stdin);
' p6 u( X- b. [8 g" p7 S                      return -1;
' v. F+ ?. Y( }+ y- r5 O6 x7 r                   }
1 B0 _) Y; R, J  O                   printf("opnd出栈:[%f]\n",b.data);; n/ j1 o1 k+ Q& E7 l  C' u
                  if(Pop(opnd,a)<0)8 H; a* I! ?7 z1 l8 Q1 ^
                  {1 f; |# M" \( P2 q  G1 ]) c% C& p4 f
                     printf("Bad Input!\n");3 c) i9 v* z: f8 W$ C; |$ P: A
                     fflush(stdin);
1 f/ c2 v/ Y2 q. S3 \3 o- v+ v                      return -1;: s9 r5 ~( W) c( l( x
                  }+ o# r$ B5 \. K3 {8 m$ f
                  printf("opnd出栈:[%f]\n",a.data);
; Y. g. U  g" V                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
8 k+ [3 o$ U. i/ p7 j. Z                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/7 X2 ?" s% T) f7 E; x$ o
                  printf("结果入栈:[%f]\n",opn_tmp.data);
' C# X/ g2 m  B                   break;: Z8 H, f/ O5 r' H
         }
2 N1 N, P+ z( g% i' V       }0 S0 E: d; H9 V6 x9 s  C
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             # {; q2 Z* x% n. o
}
0 S3 h7 t) r: B' G$ k GetTop(opnd,opn_tmp);9 n( A0 N4 }3 R' K! Z% y/ R
DestroyStack(optr);
  Z) ~" |# \9 y DestroyStack(opnd);
8 O! j% u% w2 d$ l- ~ return opn_tmp.data;
1 n1 u  v7 H! m/ E0 ]5 E- y}
+ E1 O- Y: Q$ Q
, l/ j  b6 Z3 [7 \1 n+ {- Lchar *killzero(char *res,float result)( }# S+ z4 P; J; ^* p6 S/ G1 a/ R
{0 h) f- P8 u. v) e( W% E- H
int i;
" B; O$ ]8 F' Q4 D% V+ A2 l- z) v$ ]
2 B, n# E: ~; P6 D" Y sprintf(res,"%f",result);
; Y5 @7 @7 p) w2 D# m" e i=(int)strlen(res)-1;
6 f  I3 {6 y3 ~* E: b. u1 ] while(i&&res=='0')4 L* I. V. A* R. k
{& u3 ~$ T, k$ U1 q7 v
      res='\0';
1 U6 o8 S% l4 L% ^       i--;
+ v$ u# i1 g3 ]: O: d }% l/ U  M+ Z4 P3 d
if(res=='.')
; P- d) ^7 e( ?" ]; w7 v7 ^       res='\0';
8 `$ c+ O2 H% e0 B return res;' I, G8 f0 C; U4 i- W( C& T' P
}
6 }9 L* j& i; D/ s/ U4 j
* z( U8 f) I7 L9 `" K: mint main()
( m' H, ]4 w' g0 U3 }{& L" ^. Q  i. @! `9 c
char ch;7 \, @7 \6 n5 c. l
char res[64];
* E, \( J0 ]9 F- g( U. b float result;& J2 W6 o/ K# Z; D; K) D6 X8 h
while(1)+ c! h6 e! D7 o# m% M* C
{
: z) ^! P. c) q6 H& n0 N       result=compute();
* }+ G! m& `/ C- m- |4 q3 q       printf("\nThe result is:%s\n",killzero(res,result));4 ^8 k; Q( Q1 L6 z% I" _: S: F
      printf("Do you want to continue(y/n)?:") ;8 b" u. I( k) t" U- j
      ch=getch();" F& ~+ `5 D  W; r& D
      putchar(ch);3 S2 F) Z7 `' d+ |
      if(ch=='n'||ch=='N')0 w9 p7 u$ b% i
         break;( q1 c9 @% `& k3 c
      else" |: N$ P1 s7 F  g: z- l
         system("cls");
1 w' O7 e8 R7 J; l5 P }
3 C. F4 k& s5 L" `0 D3 i+ k return 0;
7 ~5 i4 b8 g* j" v# R3 H* c}
  ~4 Y% c1 ~5 A' U
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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