C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=( X1 I" T. o# l- S; |0 D
/**************表达式计算器************/% n/ I( z7 J6 ^+ r* Z  @
#include <stdio.h>- i0 C* H- g) K' F
#include <stdlib.h>$ m" K0 I" ]; v1 g  Y- Z# v( d) A
#include <string.h>5 D" O$ z" b; ~8 m5 a
#include <conio.h>( k4 ~6 I4 q" r
#include <malloc.h>; f7 J0 H5 q8 C
. i& L- A7 O5 i) W% \
#define STACK_SIZE 100
#define APPEND_SIZE 10* A6 Y" j' r" d8 N0 Y" Q( u

struct SNode{$ s  a% Q- ]" p4 u
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*// m- }2 h% \, p
};
# _  U- J* u; ~& Q/ r
struct Stack{
SNode *top;- J3 T* ?$ G7 G1 O9 M8 b  z% \' T
SNode *base;) M! N) e0 P0 `  A& f
int size;$ v: }0 ]$ B+ k) h2 h% F
};" M8 @1 b+ n- \  h0 W' o4 Z+ m

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/! J4 ?+ d0 J! l8 f$ K4 {6 |
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/& o6 g/ x' E, l$ }2 G3 ]6 z
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/" h3 z; R8 [8 h# c4 E
; a& G: T6 w# p" \' x
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/% t7 U6 U, P  ^9 K) k" ~
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/! O' E% x+ |! O- b" {) u: q$ E5 n
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
3 M0 M1 C2 q2 x0 c" K
int InitStack(Stack &S)$ t/ {- G3 s, d& c) H
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");, l  S7 W1 [0 t: q4 O" ^
      return -1;
}
S.top=S.base;" _  n' U- T) y5 E* I& z
S.size=STACK_SIZE;
return 0;
}

int DestroyStack(Stack &S)
{
free(S.base);
return 0;
}
# V# O( B! x/ A2 _, k, ]" \% R. l
int ClearStack(Stack &S)
{7 [! m( X: w1 g3 [$ ?: ]0 Q5 n
S.top=S.base;; n6 S: Q( Q6 ], \' \
return 0;
}
  K1 [- ^: N/ W7 \
int GetTop(Stack S,SNode &e)$ p, H5 F/ {. h# b; J6 ~- w; {
{
if(S.top==S.base)9 Q7 `# D$ [" ]; f7 u! U
{2 F) F0 `. H7 e  g+ M( t( U
      printf("栈以为空!");
      return -1;
}1 {+ u8 L, O" U6 e$ ?8 S% b
e=*(S.top-1);2 x% _) w6 M6 G
return 0;8 k- l% U5 @& E. O0 h
}/ d' A! V+ `) x  O0 R

int Push(Stack &S,SNode e)
{# r% F6 B8 _" u2 U! K2 ?
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));8 D1 r& t: G. D
      if(S.base==NULL)
      {# t  G/ ^* `5 A' A' k& v( M- D
         printf("动态分配内存失败!");; g( W+ h$ c; f$ Y' W
         return -1;
      }& D+ ?% |* @; s
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;/ D( I# u& j) b
}. h( i4 S6 c0 [) ^+ m& L4 {
*S.top=e;% F( k# J' r% R% @9 g
S.top++;# o; b( a3 R1 t, P8 D# }3 |
return 0;6 R( X0 U6 z" Z* j, s
}% D) L9 u0 J7 ~* s

int Pop(Stack &S,SNode &e)) y$ P8 S- _. f1 ?! U0 V. |
{; d) X. d, d& V% B
if(S.top==S.base)" T% J$ |& T$ C: k+ _
{* Z7 M. x) S8 K' S+ D% Y* m
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);( e. T7 O; @+ s! m1 ?7 r
S.top--;# A6 e8 w3 `, \
return 0;
}0 G4 I5 `3 I4 @  Y3 _6 L9 M
' H6 o" h( |6 n4 y
char get_precede(char s,char c)
{6 L% P! \: U: t  u! L, q/ |! }
switch(s)
{, e8 Y3 P. e3 U+ t8 s8 W# q; H* s
      case '+':
      case '-':* h8 d) N0 ^: x6 t3 x% h
         if(c=='+'||c=='-')$ W5 r( S( h( x; k' f
               return '>';9 |0 M! s7 S# @' P
         else if(c=='*'||c=='/')% F( P1 T! x+ E, v% v
               return '<';  P' M: h! q1 i+ w, }* \
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';+ i0 Y; U: b: t$ U/ [3 H8 C% D; R
      case '*':
      case '/':# e8 V8 h1 W; l% r0 ~
         if(c=='+'||c=='-')5 j4 s( |# N* m. O+ o. N/ b
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else1 C) t( j. m' S# {8 O4 v) n5 d
               return '>';1 V3 ^9 p  v% Z" @! A0 b
      case '(':
         if(c=='+'||c=='-')% M$ O& m' @! R# v5 A1 \$ X# R
               return '<';
         else if(c=='*'||c=='/')
               return '<';: y* a2 [4 r; K' x  `8 s3 v; C
         else if(c=='(')
               return '<';2 }% S2 e$ O3 x) ~
         else if(c==')')/ C0 [) O# H  a8 T3 o
               return '=';! i! c) f& {, x+ r  M& m0 q
         else- H% b4 U& y6 ?4 |( M$ j8 l
               return 'E';
      case ')':' [9 e/ ?) x' P# x6 u
         if(c=='+'||c=='-')2 [! |- g2 W( o" [
               return '>';, ?  y* F6 `+ ~0 Y3 }
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';! o3 t  L" C3 H
         else if(c==')')! R& x% B9 s* P+ {7 E% ~+ Y
               return '>';
         else- p7 A' M# K2 t. d9 y' ^# z; K
               return '>';) T/ @  @) ?& R
      case '#':
         if(c=='+'||c=='-')9 P5 ]" F$ E9 F& f$ b8 E3 D2 v+ \
               return '<';
         else if(c=='*'||c=='/')
               return '<';8 |8 T7 J( M: C6 _$ b% r& {+ x. o
         else if(c=='(')
               return '<';
         else if(c==')')
               return 'E';
         else
               return '=';5 D1 ^/ a' L! M$ K
      default:
         break;3 G4 z: s0 P7 `7 x7 A: A
}
return 0; 9 _3 }) X2 T) |8 i( A* h
}
1 N7 \, d5 S- r7 ?( k
int isOpr(char c)1 c! b- R% k% \
{# D' A8 I: h3 J' _" b
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')1 h2 j) t( j" y5 A4 @1 q
      return 0;
else
      return 1;4 K. j( Y* E6 v* t* v2 K
}

float operate(float x, char opr, float y)8 @) Z. S" w5 G" V) R8 U$ E, j. L
{
float result;/ u2 K+ e$ \; }: Y: C
switch (opr)
{
      case '+': ' `4 j7 u, _" h* O( {1 {7 w' F
         result = x + y;+ _2 T7 y  P6 E- I9 b
         break;3 r& K, R' `- C& F
      case '-':
         result = x - y;
         break;; o: F6 O! w3 U; b) G
      case '*':
         result = x * y;
         break;
      case '/': ' c% Y! l( q+ |2 t! z$ _9 q% C. I
         if (y == 0)
         {
            printf("Divided by zero!\n");7 r0 F3 g6 B% ^) Q- a
            return 0;
         }
         else
         {6 m( e: S! \9 m9 r- ]8 _) L
               result = x / y;8 a0 s% G% P5 v+ J2 w6 R6 _
               break;1 S( P. Y1 x9 U3 ~+ u( N# R
         }
   default: . w  @1 W: v* w' ]! c; v3 _4 d
         printf("Bad Input.\n");
         return 0;$ F. f1 {# B; S6 a4 E8 G; g5 n
}( t2 A9 K  I6 D7 a
return result;, T& J# L& N# T
} ) C& w3 F& [9 ^. ]$ e
) O, j9 F, Q1 N# K) A
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/' \* ]7 s2 H) ^6 u, S* P6 v
{
Stack optr,opnd;& r8 C7 J  o) h; N/ q9 {8 z; s$ u: M7 a
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;7 b+ P& C7 I! T
char c;
char buf[16];2 s- M6 e* |$ Y1 u3 t" Q/ ?% m
int i=0;
* g, D1 R+ _4 M+ s/ O& L) Y. K
InitStack(optr); /*用于寄存运算符*/% z% `: Y4 d: g* N+ w# g
InitStack(opnd); /*用于寄存操作数和计算结果*/1 X6 R2 d# w! g' W( ]8 m
memset(buf,0,sizeof(buf));2 r2 E0 E( E9 j% b- C/ a

printf("Enter your expression:");5 v7 J9 M+ Y% w% @, {& P1 h6 `! |

opr_in.ch='#';: Z2 P# V% t, o/ w7 C) B- K
Push(optr,opr_in); /*'#'入栈*/9 r/ J: f, X0 A$ v
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{3 @3 E2 h# k0 [
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;3 D3 W4 t0 r% [1 Q0 j5 d6 |$ T
         i++;
6 I8 f5 l7 N! S1 y+ S; e$ Q  ]5 D6 A          c=getchar();5 j3 F+ E( L6 Y0 y& Y, T) g
      }. }) O2 @& i( j  ~
      else /*是运算符*/
9 |, Y( l! [0 u. v% ^6 v; H       {, F& V/ s3 [; @5 \7 q9 x+ L
         buf='\0';; O+ X: [( D) @
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
8 D7 e7 r1 L9 ]3 C4 i! f          {& c# u% b! i5 ~2 f5 J& V6 u5 s: `
               opn_in.data=(float)atof(buf);( n, z4 r, f" |4 U7 n" u
               Push(opnd,opn_in);
0 }/ D/ j7 T4 H, u  r( V/ t                printf("opnd入栈:[%f]\n",opn_in.data);7 V6 x$ e9 z9 W' ?7 a: k
               i=0;, a$ J6 u* R6 E
               memset(buf,0,sizeof(buf));/ a2 S" k- i! T1 G
         }
: l4 A% I3 \, I          opr_in.ch=c;
& G3 k: k+ g( G          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*// `9 C7 Y/ W# A3 f% R5 a1 k' {/ {
         {
6 O( A' k- f: N7 p" u' Y             case '<': /*优先级小于栈顶结点,则运算符入栈*/
% ?* b# K" ^& S+ j4 Z                   Push(optr,opr_in);* j( Q' @, J3 z( P. D7 n- G* I
                  printf("optr入栈:[%c]\n",opr_in.ch);/ |+ }5 X  ?8 R  ]- q8 Z7 V
                  c=getchar();
' Y( u8 W& B( O: G7 Q( Q# J                   break;
# f. _" \7 Z$ q+ G# D* }             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
& S% U2 U9 L; N+ G! \                   Pop(optr,e);
& j' U  U9 s/ e& f                   printf("optr出栈:去掉括号\n");0 n  [1 g. h7 ~* N
                  c=getchar();
9 y/ m8 K3 x0 Z6 C3 [. A& l                   break;! M  O' q) [3 _2 V! ~* K
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
                  Pop(optr,opr_t);  g. n( ]# k1 }" O( x
                  printf("optr出栈:[%c]\n",opr_t.ch);
( B9 N& j$ l3 Q9 x                   if(Pop(opnd,b)<0)" {, n+ C" _$ w# }# H
                  {
7 c' o1 L. m5 ?. ]; X0 c8 O                      printf("Bad Input!\n");% T: n  n5 f% ^
                     fflush(stdin);9 v/ K" Y" l+ M( V) i( n
                     return -1;" T3 X) i1 w1 u$ z6 S  H/ f2 n: {
                  }
( Y/ O6 `8 p$ v$ h8 ?9 H5 r                   printf("opnd出栈:[%f]\n",b.data);
- E$ s$ i8 A) W" L' }                   if(Pop(opnd,a)<0)
9 `; |' f) W# n% Z, s7 b& b                   {
, h1 {4 Z) }6 A, ?; P" n- K7 T                      printf("Bad Input!\n");6 Y* j7 K- `; x' @7 l
                     fflush(stdin);
' z' B7 W8 S) E( O                      return -1;( V# U6 b( x  J, S, ]1 F. c3 b
                  }
" e+ e8 O3 b% g& H, |/ W4 p                   printf("opnd出栈:[%f]\n",a.data);/ F  r* P  x- f0 }2 w
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/0 ^+ N: i$ Q2 v
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*// b$ w+ R0 B2 t/ G& }
                  printf("结果入栈:[%f]\n",opn_tmp.data);8 I  p' Y+ |1 T: o+ u' G7 _
                  break;3 B, r6 C  f  t& `0 S( z
         }
# G- K7 f# [, V0 b5 \  Y/ \       }; N; H/ k0 i2 T$ `% D- L
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             + O7 ]6 h+ J- u
}% [' R, g/ r8 u4 F- }. C
GetTop(opnd,opn_tmp);& B  a& g# G5 D
DestroyStack(optr);  k4 d' H. Z6 P4 p% S# p
DestroyStack(opnd);# x' R' h7 C. l) Y
return opn_tmp.data;3 Z; m% @0 h& g
}
$ l+ [; H3 n- r  N0 j3 f) O* g. K( c1 y' C
char *killzero(char *res,float result)! g2 W6 ]$ ~) h1 r; X
{  m. _  K8 b. H+ V, w
int i;1 D0 Z7 j/ J6 d- m

/ s$ \; m  [+ w$ A sprintf(res,"%f",result);' i& b, [( U# l- [: c; D
i=(int)strlen(res)-1;; k' m* x- U/ j1 V6 |2 r
while(i&&res=='0')
( S" _! [# Y4 a& Q: K2 O% P" R# s8 O {
. B2 [% K) V2 e. W       res='\0';. c% b% n; p1 P+ F% v- e
      i--;; @# O" }$ V- o, a( s9 z8 n, U
}
" a1 I: @% i' |, M( V- y if(res=='.')0 D8 O+ J9 P6 j0 O5 L3 T  \1 J5 [/ ]
      res='\0';+ a* ]' K% A7 o+ T
return res;1 F; C- |! |& f- }) ?
}1 ?9 v( t8 H: }2 T
1 F' ]5 f( v9 O4 {: T8 x- O; L
int main()5 |2 d5 g+ g( |; J* ^
{- v& V2 k+ \( [! b3 [+ v
char ch;
  m7 M1 Y/ `. t5 Q; j, e! u char res[64];  o3 r% t1 Q5 C( I
float result;. u. P/ `4 K6 g% Y% [1 L! C
while(1)
1 u& G" S* @( a/ O+ O' y {
$ F/ l& |) u, j- k3 k( O% q/ E       result=compute();
7 W/ _) {5 O9 [       printf("\nThe result is:%s\n",killzero(res,result));  b: I0 v1 g# n7 x6 ^
      printf("Do you want to continue(y/n)?:") ;9 h2 ~7 n8 O9 L3 I
      ch=getch();* U4 j, {. D' ]/ P- c2 c2 r6 r
      putchar(ch);& s' q( L5 W2 t4 B, }: T
      if(ch=='n'||ch=='N')
. m: e# k+ V+ C5 w" W( v          break;
. J5 K/ Y4 U. }6 r2 l! e       else8 n6 v; q9 ?  O/ L+ H2 V! D
         system("cls");
" L5 [# p1 i/ t$ a3 T) Y }- W% E9 R! d. X+ z
return 0;5 ?  H; B$ o# i. t. W2 Y$ x
}

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

返回列表

C语言表达式计算器

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

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