C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=, J+ E& U: S9 z+ r! f/ j2 Y3 z+ b  W
/**************表达式计算器************/
#include <stdio.h>) _9 _. r' j/ B1 m# H* w' \0 G
#include <stdlib.h>; N. k6 D: O: b+ b0 o8 G
#include <string.h>+ y: c9 ~+ y" I
#include <conio.h>7 B; A* G3 r  H  r5 I# w  i, x/ S
#include <malloc.h># R2 L+ N& a6 ^* ?+ o+ g! ^: h/ I

#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/( }" p' }# Y& z" O; N2 F7 I
};; A9 |1 l& u; r( B- a, M- U

struct Stack{
SNode *top;! S$ V/ O) j+ I: p3 k
SNode *base;# j; O! X3 y7 M
int size;% p. t( p# b' [$ O0 }; T5 I
};1 g# [; ^7 @# X- b& v) f
0 }3 w  Q4 K0 Q( C0 q# K
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/8 Y' s- l3 Y+ w( @/ D
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/1 J% N9 ~8 E% X* Q8 z8 f
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
( D  P! p9 L3 t, p3 U
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/. D2 I! B" J4 O9 j$ V6 W5 r( j
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
2 B2 T7 e$ F$ @% E0 g3 }* D
int InitStack(Stack &S)# I& q  p3 Q' i4 B3 U& Y' n
{$ I; d# `) M3 j# a: I5 }
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)0 f: ~: d+ c: r, m$ J- T
{6 j& v5 \: P. }' T9 Z
      printf("动态分配内存失败!");+ N2 H# R* [9 U4 H$ a9 g/ ?4 b& H
      return -1;1 ~% ]" A, `- L; E9 M8 D
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;, ~7 C$ [  W0 H. g; X9 [
}; _# J5 m9 n6 F
& l+ t, _& U- G; m. E7 w
int DestroyStack(Stack &S)6 w8 m9 e/ y% l! p  V8 z. e
{. J0 j9 b6 i" K! x
free(S.base);, d6 b4 d; B/ |' y0 O
return 0;
}

int ClearStack(Stack &S)
{
S.top=S.base;, S) w6 w* }* ]
return 0;
}0 |8 w& K( i2 S+ A8 c
! K# \  r6 P) j+ R$ G( y
int GetTop(Stack S,SNode &e), b- {: |3 `) q
{0 f1 R9 i, f% T9 p: W# D( U
if(S.top==S.base)7 T9 p& |, Y% \" ]+ U* z! K! R) r
{
      printf("栈以为空!");) S/ [+ ?' R' v& ~- x
      return -1;
}
e=*(S.top-1);. _8 E+ c$ n  `9 a
return 0;
}5 _* z+ E1 e8 F/ ?9 m
6 D$ x) c$ q% z$ h8 S! C/ e
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{, P4 F  o9 ~1 X6 z
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)6 P% h9 K( |. D" V
      {- d2 v9 X1 l* h9 `/ x. W: v
         printf("动态分配内存失败!");, t+ I5 z8 |2 B% d
         return -1;& l( w# F: o# U$ f2 W
      }1 g# p1 v; T/ o% |* u# V, ~* b
      S.top=S.base+S.size;, r) \0 j) D  r- J5 v6 p
      S.size+=APPEND_SIZE;4 a3 r/ i7 L; [' h
}
*S.top=e;
S.top++;
return 0;
}
4 z. S9 r. X) e2 f
int Pop(Stack &S,SNode &e)5 ^6 B8 t; Y" Z4 A3 e8 `
{
if(S.top==S.base), u# Q: T) f: e$ e) U7 t) ~1 H
{
      printf("栈为空!");" x  h& o4 v& \8 ?! z, V
      return -1;
}" x8 d* k2 @, g) n2 b
e=*(S.top-1);( P- t. [+ x8 S5 k- I
S.top--;
return 0;
}
' M# @! i3 C* R) b' s/ k
char get_precede(char s,char c)" m3 v# A/ s  E! n
{9 I3 Z  ~/ J/ C; c$ D: _$ W
switch(s)& R. s8 ?2 Z- q( b* k& k+ B
{
      case '+':                " o9 e% _0 V7 D
      case '-':3 e1 M3 P. N$ S
         if(c=='+'||c=='-'), \, N' G: s5 a" y
               return '>';* l  H, |1 ~, r3 b% o# Y% f
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';3 X9 h* q+ k. R
         else if(c==')')
               return '>';$ A+ ?4 J! V% a; u8 }) z* L5 s* q
         else
               return '>';( n5 j" N# H: P! D8 C
      case '*':1 s2 T% B9 G( I4 M0 P$ k! t
      case '/':
         if(c=='+'||c=='-')2 a9 N2 C+ j& N. U4 J
               return '>';
         else if(c=='*'||c=='/')1 W" S6 h6 u# m4 ~& W
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';1 e0 P7 H: j8 V) i# A; d* _% J4 E
         else" N; }; _. B  N
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';, ?7 Z$ B$ p5 F
         else if(c=='(')& ]& \5 ^3 y$ W1 P& T  {) b
               return '<';
         else if(c==')')
               return '=';
         else
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';$ Y/ ]( [  i: u9 Y
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='('), E& Y; R& z* ]; a* ?
               return 'E';) O, M( y7 b8 J- n- q7 F0 z
         else if(c==')')0 N1 j- k4 {+ g) w4 _
               return '>';
         else) ]# q/ S8 [+ k5 ]/ v$ F
               return '>';$ p' s1 v& E: o, |  L3 y# s
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')9 f; I4 J% |" Y2 `0 u" B
               return '<';
         else if(c=='('); l& k: @& a5 t+ Y3 y1 }
               return '<';; F( V, b4 @! O( ~9 h* v
         else if(c==')')& w. F$ }+ P1 [) x, |
               return 'E';
         else
               return '=';
      default:
         break;
}. x* K  D3 u2 o8 G& a
return 0;
}0 ]9 P4 w! f. o1 E) L' T6 j
7 F+ @5 H3 }- k
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else $ {( o, ?2 B4 a4 o
      return 1;" |) B. r2 m4 n: y; q- w
}5 E; ?6 ^- w# @1 [" K( r0 R
% I% A- F; q6 T9 N
float operate(float x, char opr, float y)2 |, l/ c5 j7 [) t" {7 C2 ~
{' A0 M! k; W: M1 B+ A# u' c
float result;
switch (opr)
{
      case '+':
         result = x + y;
         break;
      case '-':
         result = x - y;& G& u0 l2 \9 S  {3 X) Y  s
         break;; c& S: T6 \7 A: P3 Y( N7 }  k3 L
      case '*':
         result = x * y;2 t) v* f9 U& R: G) y% R
         break;
      case '/': " J- }: _" M' A, H4 k4 D' s
         if (y == 0)6 i' c" X: r# K
         {  @) l* Z( @* q, w
            printf("Divided by zero!\n");
            return 0;" {, h5 B" ]- K2 P+ O
         }9 A  N( E0 {& x) @+ p
         else
         {
               result = x / y;+ G1 m1 x5 `) |( f$ }& [
               break;
         }
   default: / [2 M' A- O. D9 g; p# e
         printf("Bad Input.\n"); ( E$ @! j: z& t
         return 0;
}% I+ K4 g' P  e7 Z# x' S+ d
return result;8 N' z1 j6 X( L5 A5 d6 F, D
} 8 x9 c0 C- Q- j2 U

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{; Q: u' u3 d; z3 y
Stack optr,opnd;+ a6 w% q  _1 a; l( W" V
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;. @$ T1 W1 C: `4 V
char buf[16];. ]0 R3 p' k. |& t4 q
int i=0;
; k0 j9 _/ k! O5 y1 S
InitStack(optr); /*用于寄存运算符*/0 `$ [- d/ a7 d+ r. |3 B
InitStack(opnd); /*用于寄存操作数和计算结果*/2 o9 R2 s$ A! i! F
memset(buf,0,sizeof(buf));2 \1 R( m: F9 r+ j' C+ r! Y$ b: k3 I
2 Q( ]  j/ V8 S9 u
printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/) _$ ?0 H$ q/ B  J
GetTop(optr,opr_top);
c=getchar();* k( x! d  z% [* |  q. A8 m
while(c!='='||opr_top.ch!='#')  K6 g$ w& ^  _6 p. z$ R
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
; Z! D) w2 P& h# \          i++;
& l. I4 C4 m6 n9 _          c=getchar();
) P, R+ ^/ ~9 z. N/ o       }
8 j: ?& m/ @- m8 m4 t       else /*是运算符*/) a1 W2 }* M! t. a
      {2 c6 Q, B/ `1 `
         buf='\0';
8 S8 c5 {7 L8 a4 [7 P          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/4 A  F% [5 A3 Y1 T* S- U- w* @
         {
9 k8 ]$ @, k6 U- E3 x                opn_in.data=(float)atof(buf);6 r$ ^7 S% V5 Q+ Z2 I
               Push(opnd,opn_in);2 L1 V' G# T1 b8 ~9 `9 Z3 ^
               printf("opnd入栈:[%f]\n",opn_in.data);3 {/ c. M) k9 n; m. H; O
               i=0;: I4 L. f0 L5 o/ y7 t
               memset(buf,0,sizeof(buf));% a7 O8 g- a( |: U$ m* {$ H
         }
, }: [, \6 E" x4 ^          opr_in.ch=c;
) V! C, f3 V9 Z& |4 V) a          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/; u8 ^# c3 o# _* X; w
         {
$ x" S: h. [- t" b8 Z% Y% W             case '<': /*优先级小于栈顶结点,则运算符入栈*/
) u6 \9 X8 N% T# J                   Push(optr,opr_in);  w- _1 l6 e& x
                  printf("optr入栈:[%c]\n",opr_in.ch);
2 F7 \, X4 N( _' A% N0 d                   c=getchar();: [/ l' {! |' U) U# ^
                  break;
  L5 d" ~0 b! d. D# \% S7 h             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
) A) E! G3 s# s2 U9 e: F5 C7 _! G                   Pop(optr,e);
                  printf("optr出栈:去掉括号\n");
0 r: j3 O. e; ~                   c=getchar();1 `$ b5 k, }- T+ ^
                  break;
+ b- f# z% F8 ?' t) f             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
4 Z* T  {( K' v" M4 v                   Pop(optr,opr_t);/ F- [. x9 I7 _) J$ ]) v" t
                  printf("optr出栈:[%c]\n",opr_t.ch);5 H/ f4 Q' L% k# A8 a: I
                  if(Pop(opnd,b)<0)
3 z! _, S! v# \+ B2 U. F" a                   {
( o( n  z0 L5 b+ B                      printf("Bad Input!\n");% O5 D. O; B+ ~' L7 _
                     fflush(stdin);
5 u4 u+ g- I# ^2 G# s" B* W! T8 q- C                      return -1;
7 P, q" b& i, W! c5 c' Z                   }1 `. [5 ]2 v! ~
                  printf("opnd出栈:[%f]\n",b.data);" `& M+ F! \0 n9 Y- _- v" P/ p
                  if(Pop(opnd,a)<0)
2 _3 B( R8 n  a# f( M                   {
, _. f+ M! ]0 m7 a" d' a6 E# d3 i                      printf("Bad Input!\n");
4 g1 J; @8 C4 ]9 B. e6 p( a/ y                      fflush(stdin);) ~* y% A" U# A& o' C4 \" ^& p
                     return -1;
- ^' r/ U: O9 P5 c4 H- C# L& F                   }: Y/ A( I# n( m2 l; m
                  printf("opnd出栈:[%f]\n",a.data);: i% |' @( w2 e/ ]- o
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/5 Y& e0 G. I* A" l% x( g  j
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
) b( i4 `7 f# o1 ^                   printf("结果入栈:[%f]\n",opn_tmp.data);
! ]7 G$ p8 v3 V- J: _; X                   break;, v& @( {' c. A- H7 G) G* @9 e! V
         }
) }. @9 l0 x) I* e, {7 K       }
! l. C3 Q; ?* f) }! n       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
4 O- W7 l  J8 X1 s3 g5 M }( J0 ?$ h( k: G
GetTop(opnd,opn_tmp);
$ R: T; D) _* {2 O DestroyStack(optr);& L0 K2 G' ?8 N7 z7 \. A- X
DestroyStack(opnd);; ^: |8 ?3 w( x
return opn_tmp.data;
! s9 v+ y" t, V! J) F. h}
/ |4 Z; Q* S8 ]5 X" r% b, b1 ^+ A' v6 |
char *killzero(char *res,float result)
  M! d5 K" I, K{4 U9 A, d; S# ]  w
int i;* N! u5 Q* I5 ~% |
' j- A, o6 o3 R+ p( j
sprintf(res,"%f",result);2 u. m( S( f# d% ?6 u' [3 f, [3 e
i=(int)strlen(res)-1;
$ A, r, Y. i2 ^2 W5 [ while(i&&res=='0')
3 d- P/ F+ k* A' D' ^; @ {
/ o1 Q3 S$ \0 e# p- f+ D       res='\0';6 Z0 ?9 Z6 T) f* A
      i--;
( B% _& W2 P+ }6 H& T  K; n- r }8 ]: |$ r; a+ A  @) n) C, [
if(res=='.'), Z! h- j# j; }& C3 \6 B
      res='\0';- D- ~- `4 M* M1 p
return res;
/ K5 [! X5 {/ B5 _7 a' @4 }6 V}
2 K( p: F5 f) q. n" B: {$ F! y% i9 {# j; {) F  l  D' i
int main()! @" B. {4 e2 F& \& E4 S% p5 L; z
{
/ a  W" P" i4 O$ [' Y char ch;
" V; a% ?+ v" x8 R char res[64];
/ B2 G% e1 X' u0 H float result;% C  A4 M4 k/ ~" n' O" ~7 T; E
while(1)- a2 ]1 m( K& ~( S+ N) @
{* n; ~5 P6 E  O9 }; q- p
      result=compute();: k5 z) b0 W. i7 c$ V0 z
      printf("\nThe result is:%s\n",killzero(res,result));+ B( U0 _$ H$ x5 i5 x
      printf("Do you want to continue(y/n)?:") ;
  n- w; e4 e/ w5 N! G# H3 _       ch=getch();
4 F2 _( W# |& D* S3 \       putchar(ch);
0 f  B+ B0 r' x       if(ch=='n'||ch=='N')
4 e- j) Q! e4 W, j7 z* }3 I) M8 L          break;+ F. L2 A5 H% f4 a9 i
      else5 n; C5 J/ z2 B
         system("cls");. O8 |9 ~8 M& R* j& E& D; p  d1 T$ l
}, w' I- q$ b; }* U$ v; t
return 0;
3 g' N/ D, ^( y6 Z& }( X}$ X; ^4 O; v, J4 j+ ^8 g
6 I9 T: t4 u* c8 m; Y( G
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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