C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>3 y2 {0 u! h, H- g
#include <stdlib.h>
#include <string.h>8 F) B! z1 Y+ S8 I' C
#include <conio.h>: h* b( n7 \" ^9 H2 S' U0 c1 F
#include <malloc.h>
9 I& }2 l4 ]. I7 |# L) D2 S7 c
#define STACK_SIZE 100# V9 \, L  }2 [1 j( W% b5 V; j- e
#define APPEND_SIZE 107 v0 O* Z6 Q, E1 M5 M
; W* j+ w+ }! L1 }, H: c
struct SNode{) u7 ^: X' @' j' C6 g* s+ k
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};) z, F8 ?3 T- w5 y# l2 v
8 r: s- Z9 P' A$ o1 @. K
struct Stack{
SNode *top;' ~# D' e- e( {* |
SNode *base;
int size;, X+ t% m2 G/ e
};/ T0 l$ N& l0 _
% a" r" w( j4 Q4 `  }- i' u; S
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/7 k0 `: v) ?  `! m- A
int ClearStack(Stack &S); /*清空栈*/# A" x* y- o  A8 u4 Y. p
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/8 G3 y4 d; ^. |3 e' [6 b
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
& B) p! {7 s: w
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/* }5 p- T5 C( v: l) H# U$ i
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)
{- m. y  j- G0 P# p
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{: x5 g9 d% ~& m' e
      printf("动态分配内存失败!");
      return -1;" c- V, N  C3 l2 [
}
S.top=S.base;
S.size=STACK_SIZE;) M+ H$ E' A( E' S0 O; c4 f
return 0;
}5 b  ], a" o( p

int DestroyStack(Stack &S)$ U2 N4 M# J. D. \, t$ f
{
free(S.base);7 b% |- B: a3 u, a# T$ D
return 0;
}$ ?- u8 R2 e4 u: H5 h# D
! M6 N% T" F0 B, D4 }# ^
int ClearStack(Stack &S)
{
S.top=S.base;
return 0;7 F' z4 ~* b# E) I( y
}/ u3 B  w% E7 N/ y$ C" J8 U
( {/ o; Z: ^$ M" m; z( g# X
int GetTop(Stack S,SNode &e)
{* O- G2 \4 e$ l( O& C) t( K
if(S.top==S.base)# [0 u* X- U# o! W
{. [& _; C! o6 c  u. T4 [1 Q
      printf("栈以为空!");! G! L' ?- ^- N( b
      return -1;
}
e=*(S.top-1);
return 0;
}/ f; p  K- C% S2 J: s; [
6 W# F- x" P. U+ n- i
int Push(Stack &S,SNode e)3 x7 C1 x( k& ]& ?: Y" U) s
{
if(S.top-S.base>=S.size)( F& K2 ~; J- `6 j4 Z6 f
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));% |) X2 s0 j% m
      if(S.base==NULL)1 F8 a" s# i' s3 b& ]
      {9 c+ a3 E5 G+ _4 E4 x
         printf("动态分配内存失败!");, l# I7 X" g( S7 s6 ^/ O8 A
         return -1;# X5 h" Q* p% L9 z+ c
      }
      S.top=S.base+S.size;0 X) a* a- D, u$ T
      S.size+=APPEND_SIZE;
}
*S.top=e;) D1 |* R1 Q1 S
S.top++;" h% s5 P) ^% I* `" z; X3 H
return 0;
}9 z3 D0 y- h( F, K* m

int Pop(Stack &S,SNode &e)
{, k3 q  T* U/ M0 r6 [
if(S.top==S.base)
{
      printf("栈为空!");$ J0 L# l1 h& R* e# Z6 h
      return -1;
}
e=*(S.top-1);
S.top--;
return 0;' Q) u. q4 f! C* g3 T( [1 r* v9 X5 t
}: k/ D& ?( g- j

char get_precede(char s,char c)3 c: r4 ]: n8 }* z( k
{  d. ?$ f- o" ]! c$ I7 ]! C" P
switch(s)
{( f% ?/ a; H1 W( K" V$ t
      case '+':
      case '-':( v7 U/ W: b) }! W  @# P+ D: Z
         if(c=='+'||c=='-')- X/ W0 d. @5 O! S  a  V  O
               return '>';
         else if(c=='*'||c=='/')1 j) N: v0 \/ s$ l( P! v# n
               return '<';
         else if(c=='(')- Y& y/ P" @) W2 F9 h: ?9 A
               return '<';* s/ k  A! c% I
         else if(c==')')
               return '>';
         else 3 j3 j: v. d6 c5 s: n4 r
               return '>';" X+ L' Y. d, D  U% j% w
      case '*':9 N' L) f  i& y3 n
      case '/':
         if(c=='+'||c=='-')
               return '>';# p. h. c+ x. d" s% W6 y
         else if(c=='*'||c=='/')
               return '>';3 `$ d; {3 W  Z( r; F
         else if(c=='(')
               return '<';( z0 B& @2 C- z7 p- }
         else if(c==')')9 P# \* P: j: S2 K
               return '>';
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')9 S+ Z0 g# a; ]0 T) U6 F
               return '<';$ V& y; z; V7 a
         else if(c=='*'||c=='/')6 B7 ]* }' t- O/ j5 z4 l2 S; U
               return '<';
         else if(c=='(')
               return '<';8 K: E! V$ Z! r# d9 g3 s
         else if(c==')')
               return '=';2 P5 y3 O+ \3 l, L& Y! W% u
         else
               return 'E';4 ?3 @+ `7 `) ]/ {; X
      case ')':
         if(c=='+'||c=='-'), a, |3 {2 ]7 M! L5 ~2 Z% `; I
               return '>';# s) ]4 Z! u6 }+ N* P& m; ~' q
         else if(c=='*'||c=='/')5 {- H7 Z# q( \& z4 Z
               return '>';$ q$ [) @% \" Y- S  _" T1 w
         else if(c=='(')
               return 'E';$ i- I$ O2 ]' G! J* ?+ g7 x
         else if(c==')')
               return '>';
         else% R  \6 @3 E! f* c
               return '>';+ }1 e2 ]1 g0 j% D
      case '#':
         if(c=='+'||c=='-')
               return '<';/ t1 X* ]( U) o/ @6 u
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')& @- H. {: g, B6 X. K: V
               return '<';, t/ W* h' F: }
         else if(c==')')
               return 'E';
         else% {. p( ~6 s+ f
               return '=';7 m0 x" y) S3 U9 w$ v
      default:: P% C  [  N& Z; p6 A
         break;# d/ W. G/ l/ }( k
}0 t% J8 {! V. p3 G& b5 F
return 0;
}

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;
}! ]3 T% c6 K5 ~2 ?
3 @0 k& C" P" ~
float operate(float x, char opr, float y)
{' r  U9 ^; i; ~3 E  k7 I1 f
float result;% T( E, ~7 E) m: b! Z1 }
switch (opr)
{) N) i- ~- S3 L# @8 q
      case '+':
         result = x + y;
         break;0 B* d3 V1 g( T2 o6 L( E
      case '-': 8 T( T- ~8 S3 }  j% d$ N5 @- w
         result = x - y;- m% d! G2 i) z2 _# F- H
         break;7 p: ^! H5 x" z, ^5 r
      case '*': / h) C# i1 t! h9 i7 g
         result = x * y;5 |8 m( x4 k  e" o. i4 T9 r7 G
         break;
      case '/': ) W7 q7 C8 D; I: R8 B: P; [
         if (y == 0)0 [( b5 h( T1 \; l
         {0 V9 J# `+ E7 b1 k4 J$ }( l2 T- [  T
            printf("Divided by zero!\n");4 a. a% X1 O' ?  T. B" z4 R
            return 0;: C  c" }0 g3 T: k
         }  i* \, X7 J3 i( p+ t# w" D
         else! R/ [! @" L; _4 l' t3 P6 {
         {
               result = x / y;
               break;3 r& v* r3 C# c2 d4 h3 Z: K  Z
         }; k$ S9 U) F0 a, K
   default: : H1 P4 K* v/ K/ w$ |8 j2 P4 B, n6 m
         printf("Bad Input.\n"); 9 k5 ^# U* n/ Z7 [( H2 H6 y
         return 0;+ `' _+ C$ E- E, i  r2 q
}
return result;
} 4 Q2 M' [- X. R' P6 q/ K
3 q# w; F8 q; I2 p' B
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;; f& c  P0 z. U5 v  C9 R
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;4 B7 {( m/ v0 d& A& V+ z) ~4 Q
char c;) g6 I. {" O5 [. M! v
char buf[16];3 Q% ~5 ?2 b' G
int i=0;$ [( j2 m0 B" Y+ V* q
7 Y7 ]' V5 e+ M! X& x
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/& I8 D9 R1 C  o+ R
memset(buf,0,sizeof(buf));

printf("Enter your expression:");
      4 C! Y7 c5 y: v1 e) y3 I
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();' w, U9 \, m% o4 i0 V  x
while(c!='='||opr_top.ch!='#')' ^9 c! q1 |4 ~. N8 y, J; d5 y
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
         i++;
$ U) X. N* ~# I2 W& C          c=getchar();
4 V  M$ C4 A% m1 Z! g6 n7 l       }; J* u7 h0 O( t7 x; ^* R, E3 ]
      else /*是运算符*/# O. \3 I* l3 `  G' V3 [0 @
      {
5 s4 c( S0 E* N. ?          buf='\0';2 S8 U" X1 }. |% \/ K
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/2 p' Q( i4 O  C+ L
         {
9 w7 E$ r- r7 }                opn_in.data=(float)atof(buf);
$ S3 y! P% d4 X  I/ P2 x% _3 Y6 _                Push(opnd,opn_in);0 Z& n5 I& x; e* r# S/ ~3 i
               printf("opnd入栈:[%f]\n",opn_in.data);* X  ?& |0 P: K
               i=0;
4 B9 X- z/ K& \2 J, e* l' {                memset(buf,0,sizeof(buf));! r8 D6 Z9 x1 k% ^4 |6 t2 m8 F
         }
5 n( Y( F8 Z0 J: s          opr_in.ch=c;
- a( @) R% f9 [: Z( M          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
+ m9 d% q% i9 ^% t! z6 k, u          {/ Z' E* P+ K/ D2 v
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
( w! b1 n7 |* H* j7 Y( c                   Push(optr,opr_in);
; `2 }  ?( U# ^) p                   printf("optr入栈:[%c]\n",opr_in.ch);
; A% {4 G5 r1 G% s% r! m                   c=getchar();
6 K8 T. @7 ]3 P+ X                   break;& C: V9 p" L9 T& k9 x, c
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/, j% }$ c' G) L0 F; Q
                  Pop(optr,e);
7 ]' N# h1 r1 l3 _                   printf("optr出栈:去掉括号\n");
+ w4 I4 f/ z# v2 }5 ^/ |# z                   c=getchar();' e! m* Q! D6 V  s  \/ b5 T* Q2 W9 j
                  break;6 Z0 Y% p4 l$ T/ ?
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
& K4 M( w0 J  O  r( V/ W                   Pop(optr,opr_t);
7 ]# X# Y" E  [1 n& |                   printf("optr出栈:[%c]\n",opr_t.ch);2 ?4 @' t0 S% o' u; n$ G( q
                  if(Pop(opnd,b)<0)5 @% H; N9 `9 d$ Z+ F
                  {4 I1 p5 E' J( z% c  j- `! r
                     printf("Bad Input!\n");" S2 c: K% M# A$ l+ q1 B
                     fflush(stdin);
, T- K# D$ X  J$ O" r2 e                      return -1;
" w7 \0 S- I& n% D( G! F                   }
6 s* C! H; n, T# A                   printf("opnd出栈:[%f]\n",b.data);- s6 }. d' N! }5 O# U3 ^
                  if(Pop(opnd,a)<0)
' F* }9 W5 Y, p8 d) U! I                   {) Y% K, i' L: ~) {, l
                     printf("Bad Input!\n");
( y1 S  c7 k( y0 D" v7 B, c                      fflush(stdin);; x+ z+ i* i' g8 q- N& m
                     return -1;$ f" E. G% A' \5 C4 y3 {
                  }7 D& u0 w, r5 }8 V" P6 {
                  printf("opnd出栈:[%f]\n",a.data);- l* n; d% S4 e  d. n2 R1 e+ C
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
3 R7 w- p. e, F                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
6 `$ |2 O3 D7 j3 w/ p- [' x                   printf("结果入栈:[%f]\n",opn_tmp.data);/ m; U# H8 N7 i1 W' X5 J8 R4 c0 M
                  break;
# _/ _6 Z; M, }% V  W: ^6 d          }. N5 m$ [$ _3 Y$ K( ^9 A
      }+ Y2 ]& x2 ]8 {* ]3 Q
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             * _3 m' y% O: [0 w
}
  U- k- u" W  s8 t GetTop(opnd,opn_tmp);
0 w; O7 R2 G* j  M* a/ Q3 x8 f+ n; ] DestroyStack(optr);
9 z4 y3 d6 c" s6 U7 B5 O% _ DestroyStack(opnd);  v* o5 }3 E6 i; D$ y
return opn_tmp.data;! v, Y5 V& E2 T& t) k
}1 ?" G* ~3 L: h1 W  D

# m/ G; x. J% m- xchar *killzero(char *res,float result)
+ k  c, ?4 U7 i  _0 D{4 V3 k% G- s! A) r) o8 X; g; K
int i;1 Y1 @! \/ U" w2 x( O
  Y8 @" l5 T( N& d8 ^! K3 I6 s
sprintf(res,"%f",result);
9 t  S- x, M' f/ u. G0 N i=(int)strlen(res)-1;$ k8 |" p) v' J) m% A. Z/ L! v
while(i&&res=='0')
+ J6 P6 O/ k$ G' B; U1 A {
4 \( T6 f' Q5 W+ y/ _       res='\0';
3 A8 w0 n. p7 _0 @/ J! c3 ~. Q2 \       i--;/ I" K6 c! v: }" v
}$ R8 K' _. q6 [  g9 i6 A- s
if(res=='.')' Q. G- Z' }: B( T$ E; x, p. y, l) G
      res='\0';
/ I5 R7 p* j' Q9 t return res;- m$ e# \4 Y. R8 G' N% e6 ?
}& ?  Z* v' B3 d4 D: N

7 |* A/ o/ B9 l6 mint main()
4 U6 ^* t% ]. V: A, i' u{
5 S8 D  R' @* G' |0 l char ch;  C7 k, e# V$ ~& h3 }; @0 b3 o
char res[64];
6 T9 |2 v# G( Y/ y. D& }  s# g( q float result;0 H8 A* n* W+ w) ~
while(1)
: C5 ^+ T: P+ \& ~$ ^% g {
( d& B( H& N4 [; f0 N+ O       result=compute();$ t, h5 `* A) M' ?2 Y* L
      printf("\nThe result is:%s\n",killzero(res,result));
8 ~) {- ?' z3 w6 k/ h       printf("Do you want to continue(y/n)?:") ;" \" p& H) I  h* F# Q; X  ~1 B& P
      ch=getch();
. S1 F& X, p* G; }       putchar(ch);1 S( L! a# ^/ ~- [; g9 f
      if(ch=='n'||ch=='N')! ?4 H; Q# s3 s4 @# m
         break;3 X7 [0 X% x- o6 a  w! H
      else; z9 i( x) J. q0 I$ R
         system("cls");
* k" D7 c3 U% G. t }2 Q1 Q- P# b: V/ k" u& R
return 0;
" ^5 s. @9 m" U1 V, |9 E- ]}
/ q3 j( b5 n6 K$ E
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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