C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.8 o4 ?  ?/ @$ F6 |# i& d, D
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=* k; T" \& y( d. p! c1 ~/ R9 B
/**************表达式计算器************/
#include <stdio.h>+ s. f( j  B! U$ T, D
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>
7 B/ ]/ o3 U  h& B" U
#define STACK_SIZE 100
#define APPEND_SIZE 10; f* m6 a7 f. }, v( m! O
& ?  U) `9 N7 J5 C" B1 f
struct SNode{
float data; /*存放操作数或者计算结果*/, I- c) H" ]% j, {" {
char ch; /*存放运算符*/
};. D/ S6 M/ N' J

struct Stack{0 S2 \) ^( S+ I. j
SNode *top;, [/ o! F* v6 a( \# B8 l' }. a: |2 o
SNode *base;
int size;
};

/*栈操作函数*/0 x/ r, ]1 S$ f" v- O# W/ i7 \8 Y
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压入栈*/1 Z, y: f0 U! {7 i3 t5 X
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/0 |7 i4 I+ j4 k, D% C
  @, G9 y6 ^7 L+ J# M# b9 W* l
/*表达式计算器相关函数*/3 ^6 L* O" F6 S$ q7 W) t3 i
char get_precede(char s,char c); /*判断运算符s和c的优先级*/8 l3 g+ c$ {1 c
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/* l& A/ t8 G' w  c" f6 L3 J- q
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/1 |+ }9 \7 ~5 z+ C6 e
char *killzero(float result); /*去掉结果后面的0*/
+ w, {* o; ^& a* G( M
int InitStack(Stack &S)( r1 r9 j; b/ }) V7 ^: N! \% k5 {" ~
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)3 H6 j/ ^* E+ q; I. e8 P6 c) S
{
      printf("动态分配内存失败!");
      return -1;) f$ I" U6 N$ v2 z1 C; F
}* q( w3 T! P/ w1 }5 y
S.top=S.base;
S.size=STACK_SIZE;
return 0;
}% {; B' y9 p3 s% f# q* i. t

int DestroyStack(Stack &S)
{
free(S.base);* [# }8 Q* }5 H8 U
return 0;
}9 Q6 V& e0 ], x3 w1 |9 M% u& g
; W7 @9 x* c# e9 @8 C1 p$ u
int ClearStack(Stack &S)( ], ^6 F( ?0 C' w7 I
{
S.top=S.base;# j2 H5 x. p' b9 Z, k$ Y9 w
return 0;
}/ p; `( C( y1 v; ?* A( A

int GetTop(Stack S,SNode &e)5 }4 _! k6 g# t0 E, L
{
if(S.top==S.base)" [7 b2 w9 e+ W$ H1 A
{- m! D6 I4 b8 o: w* o, g: V
      printf("栈以为空!");. Y6 z% S4 j1 o5 J/ Z
      return -1;% i$ q7 |( v8 ^- R& c
}5 N9 e! y1 f; s
e=*(S.top-1);
return 0;+ e) N8 v( y! p) M9 S- y3 z
}4 T. p3 z9 d! h! z2 c' Y

int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)+ ]% u3 I3 u/ {, r8 ?5 c
{( ~7 ]+ V" \& j( q2 U( b2 a& y8 B8 U
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));( o4 a' o! t2 U) ]7 {
      if(S.base==NULL)/ V' o5 v5 k3 l- \9 W) b! c
      {
         printf("动态分配内存失败!");$ \% u$ n) i- d7 B* l4 a
         return -1;
      }, U% E% S' X4 G, c" {% c1 \0 J
      S.top=S.base+S.size;" b- E5 i8 |7 x) M4 h3 q
      S.size+=APPEND_SIZE;
}4 @6 D3 I+ M0 ~
*S.top=e;5 i6 U% E, o0 m8 n0 d( U
S.top++;3 D- \% {% P( c
return 0;
}
6 S& O) ]( j) \$ d  N5 p
int Pop(Stack &S,SNode &e)
{7 F( w0 J7 @) r6 d, E+ G2 o
if(S.top==S.base)
{  i# H' o0 _+ E5 X7 R2 L4 o" e1 I  K
      printf("栈为空!");2 j6 y0 k: B& p9 r9 ?2 q
      return -1;
}# a. d0 b4 F; i" k6 U
e=*(S.top-1);8 O( a! c, T) a# R' i2 j$ g8 R
S.top--;) l1 ]6 `/ `. a! t/ h
return 0;
}
& \! r. n9 A- u/ w/ L( }. h
char get_precede(char s,char c)' V2 p$ S% x, H  ^0 b  A" s+ @- }
{) k/ v. o$ K+ f0 F/ C
switch(s)
{: N6 X/ ~4 `6 J* ?$ G! J0 V8 e
      case '+':
      case '-':
         if(c=='+'||c=='-')- s0 n! W  ?' L' j
               return '>';
         else if(c=='*'||c=='/')
               return '<';' q+ C5 @$ b, ~7 c" Q
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else , R5 T: Z3 `0 O5 N
               return '>';
      case '*':7 O" a3 j" V2 v
      case '/':2 o6 R  q) J; L
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')5 s: r! e* `' t
               return '>';- ?' e$ d7 P) b2 a4 O
         else if(c=='(')
               return '<';2 Z2 w9 P: k' E! o( u
         else if(c==')')
               return '>';
         else
               return '>';1 Z4 ~0 e9 x4 F$ f7 L* S/ N1 t
      case '(':1 N! W  H. F7 A& _8 N3 M2 O
         if(c=='+'||c=='-')% s4 e+ o+ c/ }
               return '<';* L* {  o! t$ d1 }9 F) }) M# J
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')- ~1 s# H6 a- D0 R7 O% y7 B
               return '=';
         else
               return 'E';5 v2 \$ F( S# z. r
      case ')':
         if(c=='+'||c=='-')
               return '>';. f9 a) y. q. \6 S9 b0 Y1 d
         else if(c=='*'||c=='/')
               return '>';+ P* b9 T, B) \" m$ m
         else if(c=='(')* B1 k* N! o4 o! `5 C$ J4 P
               return 'E';& X1 R1 x4 S6 J! h1 u* |* G
         else if(c==')')
               return '>';- i/ S. J5 p- t9 \% B7 C& K
         else" d5 R; I; F- j/ m' `5 |; ?
               return '>';
      case '#':, t; t6 t2 }% ~2 T0 t* f" v
         if(c=='+'||c=='-')' \" z( N( @- z( u' n
               return '<';& T  U# d# L$ c7 r. c' c" \2 Z
         else if(c=='*'||c=='/')6 @/ N( S/ n; t4 U* R) |, J1 f) \
               return '<';
         else if(c=='(')9 h+ s8 `1 ?# I4 Q/ S( M) ]
               return '<';9 i1 \9 `- A2 K9 Y
         else if(c==')')
               return 'E';
         else- v7 t( Q; l6 l6 K* j. h. |
               return '=';
      default:
         break;# D$ E  |2 V$ U" G
}- J1 M' W% }2 J: f: l2 ~$ N# X
return 0; 7 u1 [7 v( ]; c) X5 @
}
) h- c' F9 W: {9 O2 d( d
int isOpr(char c)
{) _7 f6 C; M5 J4 k2 _# l" |
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;9 X3 [, ]; Y4 U# G" i: ^
else
      return 1;
}, |# Y$ U1 D* ]2 p6 i  `

float operate(float x, char opr, float y); E% S. @# v) _% F# M
{7 g. f0 R6 W9 J; ~
float result;
switch (opr)
{6 r, B3 ^2 r; }5 K9 ?, |, B
      case '+': & |* N4 T' v6 m- ]- ~
         result = x + y;7 `2 q6 F$ k; ?, V6 y
         break;
      case '-':
         result = x - y;: c( [, _7 b+ _& R6 c2 S9 m
         break;
      case '*':
         result = x * y;( O) N2 ]8 J9 ]/ F3 ]
         break;7 {8 B2 y7 X' ]4 G. S
      case '/':
         if (y == 0)4 P+ s. V* r, n) D" g9 m7 ^, y
         {4 z0 y" s& B& x# M# B+ {$ w& U
            printf("Divided by zero!\n");; \7 S( q/ V5 U# U4 |& d+ z$ B. g9 ]
            return 0;# S( x3 v4 d6 ^* }5 z: r7 u
         }
         else* ~; o/ g. {4 V# ^- }/ Q% P
         {
               result = x / y;# K& S. g0 x; d
               break;
         }5 w5 I7 {8 X$ E( ]* C  x" a
   default:
         printf("Bad Input.\n");
         return 0;
}- \  ~6 `3 T4 a- Y& J
return result;
} " r: D. U' a# |4 u- `

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");: O( d# p& c# j0 U

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/. w/ w  i* O$ K2 N$ p
GetTop(optr,opr_top);, |4 Z3 I1 R- o* q, h& i7 _4 a7 Z
c=getchar();6 r; x& ?+ L5 `" _
while(c!='='||opr_top.ch!='#')3 a, P8 D* z" w' f
{: ~5 t; I/ h1 {3 Q; t0 n% X% F
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/5 ~7 b$ n9 X/ c0 m& Q! d
      {4 ?8 u- M9 v5 ]2 M2 V$ s/ T% U2 X
         buf=c;5 r: K7 G0 y% R
         i++;
& q7 M9 G. N4 ?# @5 \% d          c=getchar();
2 p/ l- f2 k; g/ V0 H, G( D       }
% }" \7 {# U. m* P       else /*是运算符*/1 F7 S# O4 Z; k' q7 @* J% d
      {3 H6 }' s! ?" ?, A3 E- g* t; `
         buf='\0';' V1 i. |' y7 n' F0 k4 T
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/0 F; y0 ^' ~5 d
         {
9 S5 O4 X2 q% h' V' k  T                opn_in.data=(float)atof(buf);" p3 [2 |2 I" N
               Push(opnd,opn_in);
+ I0 w% I1 q/ Z& l" B% F3 `9 |                printf("opnd入栈:[%f]\n",opn_in.data);1 X# d+ G' D4 x2 V
               i=0;# c# W! j  E! |# C  T+ n. V
               memset(buf,0,sizeof(buf));% F# T+ G0 Y* z9 R1 M* ~! W* P
         }
4 m$ |! \2 U: t, V7 O! t          opr_in.ch=c;
1 C* g9 n6 E5 m7 U/ m& X          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
4 V5 ^& w" Q' J2 K          {, E: X$ c$ q4 U; ?# p$ e' G1 |
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
) {' j: }1 o. N0 u. ~2 u                   Push(optr,opr_in);- ?" G* u+ {" r3 M
                  printf("optr入栈:[%c]\n",opr_in.ch);, f. ]4 m8 O: n% B: _6 i
                  c=getchar();
& v% P# K% ^. W4 o                   break;/ F+ J4 b2 O$ y" l  C
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
, P- t4 t6 q/ J7 g0 m                   Pop(optr,e);
# B& p! Y. g( f$ U% w                   printf("optr出栈:去掉括号\n");, o- {* b! t8 `4 O) Q, r# }
                  c=getchar();
) o9 }! G7 t# n* G+ a" ?. D+ C, D                   break;. g; }. _/ ]/ Y. I5 Z# h( w' z
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/' D7 z$ V; F( w# C' P0 e
                  Pop(optr,opr_t);
9 H+ f' h( O. P$ y                   printf("optr出栈:[%c]\n",opr_t.ch);
/ S$ t8 f) d: i- f% ~) O3 x+ }6 e. ~                   if(Pop(opnd,b)<0)
1 y# ~- l. j, C! d+ S                   {& r% m9 o  o  X3 e* h
                     printf("Bad Input!\n");
2 B, V$ J( x. Y                      fflush(stdin);9 f$ y: B# ~& _
                     return -1;
/ K! @8 n2 j$ K6 z7 D8 }4 `" y                   }
+ L& L1 I3 ^9 ]) i6 J                   printf("opnd出栈:[%f]\n",b.data);
: _% G9 X- f/ E5 ^1 E                   if(Pop(opnd,a)<0)
% ]6 t9 R. q) S$ Q4 k0 J                   {
- W7 p. ~, _, m2 v9 r8 l7 l; H                      printf("Bad Input!\n");
" p* E( G" C9 D) S7 d* E' |                      fflush(stdin);
0 W  Q; m, i# T3 W) _                      return -1;
5 C; C3 L" s. _. m$ Z$ y- c# T                   }
" P$ U" x& r5 ~# h& ^( [                   printf("opnd出栈:[%f]\n",a.data);
) g, V* C" J" E4 Q                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
0 h. D8 w9 E  I! d2 {; d                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
) k  A- t  ]# i" `5 z/ @( O6 `$ G                   printf("结果入栈:[%f]\n",opn_tmp.data);$ @7 N  {- m- a& `. w& M) D, x. E3 s
                  break;' P& d2 o# G+ ^% q. c& y
         }6 J9 \( f6 y2 Y. e, Y  w
      }
3 n- U* o; ^6 ]6 F: F+ ?! s, C       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ; Y  C9 Q; R, n5 E# Y9 I+ ]- y& \
}7 p7 _- b9 t& j, x: P4 @
GetTop(opnd,opn_tmp);
$ S: r# v8 [* D$ [ DestroyStack(optr);
* _# r* ], R3 |0 v3 Q DestroyStack(opnd);
4 ]: k$ y1 A. g" p; a; s return opn_tmp.data;, U7 L9 Z8 P1 o$ G) I! V
}$ G: I! p6 G! O; B/ ^7 |# I9 ]6 M

$ p# e' T3 e1 W% e! lchar *killzero(char *res,float result)
4 G. s3 [; g' v+ c0 g5 l9 e{0 l. T; C4 Z+ V7 j7 H
int i;
6 c* M8 ?, R1 _' g% u6 j5 `$ s) l, V5 Q8 r
sprintf(res,"%f",result);
# j0 h: M% T. Z  @ i=(int)strlen(res)-1;) a( l8 k+ D9 _8 K& j
while(i&&res=='0')  X& u% q$ F; K
{
3 \- Z4 W2 q: J       res='\0';
! P  x( F  v5 S# A) c, ~5 n$ b* K       i--;6 |! W: m8 i1 Q0 u7 P- w/ T
}( F: Z$ ~. M6 x4 z1 F! P$ T3 G
if(res=='.')
' |# O! }& _# P# y       res='\0';
) w  u, l6 S" Y6 O% f0 O; R return res;
9 M6 ?5 C# W1 G4 D! E0 X# j}
/ j3 s/ k; Q# X# g
. h+ x+ o8 J/ S5 I# Uint main()) N0 }2 v. F, h1 P, b% J9 X
{' y/ \: T+ V% H9 U! w1 N" a
char ch;' {* k, r0 x' Q. l/ A: I
char res[64];* F( j+ v3 ?* p& G1 i
float result;  I1 e- \+ r" \9 A/ X1 y: N( n1 E
while(1)0 C- z, i0 l( d. }& G& n
{
- f+ p+ J# ?$ X8 n0 s; u       result=compute();
& Y  B' e0 C' j: e       printf("\nThe result is:%s\n",killzero(res,result));
3 Y' `! Y  w1 X3 K$ k0 d       printf("Do you want to continue(y/n)?:") ;
4 K0 w4 p  e3 }2 i+ I; t5 q       ch=getch();6 F7 e- @$ ^# n/ h* K
      putchar(ch);+ C3 B5 ^6 C4 K" L0 \: W' ]
      if(ch=='n'||ch=='N')6 e. j2 y$ ?+ p  y& }8 a, c. u
         break;3 [0 Z: B- x" `( C5 ^3 {0 C
      else
* Y+ E* u/ \. Y& s          system("cls");' E! f3 v1 o  J/ d6 G
}
% a% w; E  k/ M0 L5 e) S7 Y return 0;! g! ?9 q$ L" p7 s2 R* W  h
}4 ]* J# D$ ~  v9 o- ]( D

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

返回列表

C语言表达式计算器

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

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