C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=% P  ~: a5 G  [2 `8 y
/**************表达式计算器************/6 \; A4 I0 E; w+ W+ X' d3 i
#include <stdio.h>
#include <stdlib.h>
#include <string.h>$ }& V& j" F* I  G' @$ b
#include <conio.h>* i: C0 D# I! H
#include <malloc.h>$ ^8 p/ S8 X: r
3 s- b3 A" I: r
#define STACK_SIZE 100; F8 H9 K9 Y( }- l* I
#define APPEND_SIZE 10, G# R' b! o; i% J8 ^! c
% I, c4 x: |- W! l
struct SNode{
float data; /*存放操作数或者计算结果*/! j; |# {$ i4 z" A9 b
char ch; /*存放运算符*/
};

struct Stack{
SNode *top;
SNode *base;, F3 g3 h* I6 Q% k* l! v
int size;
};

/*栈操作函数*/* x4 j9 \- Y6 M8 f  l" M
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/, {4 m) s$ o; ?, M' w7 Q
int Push(Stack &S,SNode e); /*将结点e压入栈*/4 E* n1 Z3 W. t# _  ~6 P
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*// J" P: A! y8 \4 E! S( J
! a0 W  p& }8 e' l! ?1 C+ h( `
/*表达式计算器相关函数*/9 @; R5 f. o( ]' o4 N: w0 ^4 W4 u
char get_precede(char s,char c); /*判断运算符s和c的优先级*/1 t# O6 `  o) Q
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*// W6 e; L. T' h* P
char *killzero(float result); /*去掉结果后面的0*/ 1 I, h/ f! k% g3 J0 b2 A

int InitStack(Stack &S)5 |* o6 W$ y- @/ c9 n% y
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));) c& Y. T3 z$ m
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;$ m  A0 ^- P- ~( e
S.size=STACK_SIZE;4 x7 N$ \0 y" _6 ~2 t0 b, A8 m
return 0;
}

int DestroyStack(Stack &S)
{
free(S.base);: I" D4 z: B" Y) Z
return 0;
}2 Q0 @) h, f( ^) j8 }

int ClearStack(Stack &S)( J& w# }3 E; O. H- [( |. ]
{
S.top=S.base;
return 0;, Y" P9 U$ }( b! p
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)
{: J, Q+ O& ~& ]  L
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);& i9 M$ z* |6 s* g0 m
return 0;
}

int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));. S8 J; f1 B! D# ]7 \% g* j, j' u
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}
*S.top=e;
S.top++;3 L: [3 n' U6 @2 D; J+ c
return 0;
}

int Pop(Stack &S,SNode &e)- c7 C) r; v* f$ x1 j4 d" G
{
if(S.top==S.base)8 K/ Z0 L# z8 ?8 ?
{, @# T# w; P. Z$ C3 V# W
      printf("栈为空!");
      return -1;
}7 _0 B) w- _: I7 n/ z
e=*(S.top-1);2 s9 W* x5 R( P& m- t  P
S.top--;) p. f0 p8 u3 L' L# U
return 0;
}9 O( a) v: Z( M0 o$ U. ^5 p
  ^; D, G* b2 ?; h* }0 L+ {, L/ n4 \! b
char get_precede(char s,char c)
{
switch(s)
{
      case '+':
      case '-':: s$ y) ]2 A7 p2 A; w1 L
         if(c=='+'||c=='-')/ R/ n: G, e+ U4 j" f0 ]
               return '>';' G+ |$ y$ H+ ?- M0 z( ~- L
         else if(c=='*'||c=='/')4 B, N; n' H: [+ ~' K. q6 C7 \) N
               return '<';
         else if(c=='(')
               return '<';- K6 y( i7 ]: ?: q  E4 X
         else if(c==')')
               return '>';9 c$ x$ A4 @# k) C" Y2 u& n/ k9 m
         else
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';; i/ Y; J3 U! d& J
         else if(c=='*'||c=='/')' v* C4 O& b: {+ n8 r' W
               return '>';
         else if(c=='(')8 |3 j4 y( o. Y9 o1 h. p5 ^- H) K
               return '<';7 Q3 }8 A5 s3 v) V( Z
         else if(c==')')) k) C$ k2 z4 x0 s
               return '>';
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')& d$ b+ D6 {' X) ^1 r* U
               return '<';
         else if(c=='*'||c=='/')
               return '<';. r& P$ Z+ V( M  z) P2 Y
         else if(c=='(')
               return '<';. Y  c, [6 m# X1 Y6 P5 U
         else if(c==')')9 o2 m' Z5 v! S( c4 E  o4 s
               return '=';/ _6 W$ V5 l3 I  D7 v8 ]- i- k
         else' ]3 D7 g# G) b0 j7 W- i* J
               return 'E';1 H* e1 u/ ?, j7 t: L2 x' q4 n
      case ')':
         if(c=='+'||c=='-'), @* E" P! W) I/ \
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';' W$ K7 e. _7 w6 b( r8 k, V( G
         else if(c==')')
               return '>';
         else
               return '>';
      case '#':4 `" |6 N; K2 U, `
         if(c=='+'||c=='-')9 V/ D5 R# t+ L# q" e( H
               return '<';
         else if(c=='*'||c=='/')
               return '<';6 i4 D7 O; |7 q  S! ]9 Z
         else if(c=='(')8 T7 m6 r# d" }* [1 N
               return '<';9 j# y7 K8 q* D
         else if(c==')')
               return 'E';  z9 N! G  C* m! $ E9 j! O9 [1 h$ j
         else
               return '=';
      default:: \* j) {3 h2 @
         break;
}. _; u  F: g6 N
return 0;
}
: G9 _: o, ]' C; [! L! I
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else 3 w  K% K- T( B9 R) B3 o
      return 1;
}% ^  g( $ ~3 L' e: C; i& {$ v# o, z

float operate(float x, char opr, float y)$ i9 E' }' m3 x- o! `
{2 c& a4 H$ _+ C! j/ r8 r
float result;- J& ^( q7 B* `  ]! b7 P7 J3 v
switch (opr)3 g" k9 R; G* L
{: U: f' X& m( x0 U) j3 U. q
      case '+':
         result = x + y;
         break;( J' n" p8 q, B, a
      case '-': 8 S9 ?$ d; y: B4 V$ \$ M% j
         result = x - y;
         break;; _  y  O6 d( _+ a
      case '*':
         result = x * y;0 H4 B: B. A0 j8 z+ e; H
         break;
      case '/': 5 D5 t- T; N- T4 ~  R( M: f& K2 n
         if (y == 0)
         {6 \4 U' p5 D# B% N% z
            printf("Divided by zero!\n");6 I5 [1 V% q" B& a( H' O( F
            return 0;' r3 y0 J4 @# R
         }  U8 }9 @& ], g9 A2 n
         else
         {
               result = x / y;2 T" a0 u" R# D( _7 N
               break;( v' @+ D/ o8 H+ u% N) N
         }
   default: % g, ^# T1 D9 N) d& V
         printf("Bad Input.\n");
         return 0;4 r! I% Q% A* o, n2 I  E
}/ x: O: d& \4 e& Y+ h
return result;. A5 u+ h1 n* k$ G3 \5 z8 f) o; ?
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{0 g$ u4 ]' J& x6 G' o7 g2 |: K
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;( K( H7 q  e0 _. x9 l
char c;
char buf[16];2 k2 e  M- W( }. e/ q
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
6 ]& h- R6 p: z& P
printf("Enter your expression:");- T* p$ c7 w" K1 n. t4 K: a& F; p( F$ q
      9 D) J! G  ~6 V/ y+ s* m; c
opr_in.ch='#';: S/ w- E9 R; i/ q; F$ f( f9 l
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();5 k# q; U  M$ \, L, c' W
while(c!='='||opr_top.ch!='#')" y" g) x* W3 `9 x+ P3 w8 R- w
{3 i8 b* J, s/ u) F3 G
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/- ^& K: G0 S0 m$ S# O' Y
      {; w3 W$ j5 k6 C! F4 Y
         buf=c;
! L% T" k# w: Z. D+ t; _          i++;
& A- b& A  w! L3 ~          c=getchar();
3 `3 T8 `5 |9 L$ }: G       }
/ D; c* Z' J# k. F8 j. W       else /*是运算符*/
9 n* o* q- _* d& v. {. q& E! x       {
* D$ p  t, ~/ ], H          buf='\0';9 u0 O/ v: X! Z; Q. n
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/9 e' o( J3 G. b3 q' ^# q" o
         {7 r* E( D) _5 z! H
               opn_in.data=(float)atof(buf);/ i# e: K& i* ~, _8 K
               Push(opnd,opn_in);
0 t8 c2 {3 c2 T. }                printf("opnd入栈:[%f]\n",opn_in.data);3 M" p0 x0 }5 P& H1 K
               i=0;# ?3 K  m; U: f7 T+ A9 Q* c3 g
               memset(buf,0,sizeof(buf));
; G* I, Y( N, `" E# H- W          }& I' \) X' ?. V( F2 R' \* [
         opr_in.ch=c;
: ?$ i+ r9 O7 x' m  K+ j6 z2 n          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/2 K/ f3 W- p( ^  K" u/ A
         {
7 \/ P- A% G( E$ Y             case '<': /*优先级小于栈顶结点,则运算符入栈*/
7 G* n1 A. ]) T, d. [% K                   Push(optr,opr_in);( H! u+ m" }! _
                  printf("optr入栈:[%c]\n",opr_in.ch);( z: f4 b5 o9 \- R8 p
                  c=getchar();
8 N  Z9 P/ w( {0 H: x                   break;1 E( {3 t) \, @& i/ K
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/" t: m. N; v/ {: q
                  Pop(optr,e);
5 _% V& z" J+ t* n) d. i                   printf("optr出栈:去掉括号\n");
+ N, i% d' d6 [$ r                   c=getchar();) H& S2 s2 I- a9 v! L
                  break;" [0 ]5 N0 K4 o* y$ X. c& @2 b# a
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
# L# [* d2 J! d; J1 w& Y8 r! T                   Pop(optr,opr_t);/ j* Z3 b- N3 ?5 q. l6 P* W: ]
                  printf("optr出栈:[%c]\n",opr_t.ch);3 w, \3 k  a( @& H$ k+ }* ?
                  if(Pop(opnd,b)<0)
* R/ A" l& a3 H% F7 [                   {1 G; k# F8 O% y' B: a# k* o" W1 c' x
                     printf("Bad Input!\n");
3 y: k  E+ k0 a* T5 X  v                      fflush(stdin);$ A9 l% ~- g5 E. H- {6 s
                     return -1;. ^, O3 s' B, P* k* R: [
                  }
3 a+ i5 t. d" s, @" ?! v                   printf("opnd出栈:[%f]\n",b.data);7 k: t  o1 M' E  s1 }+ P4 B) Y
                  if(Pop(opnd,a)<0)
7 m# x$ N; T1 g2 I7 K. `% p8 U8 M                   {
$ W/ n' z- b  ]1 j4 y# f                      printf("Bad Input!\n");
$ d2 u- D. ?$ Y                      fflush(stdin);& O1 m) L/ z# q" o) o, e
                     return -1;
0 O( z+ X3 k& S5 {9 f                   }
; X& {* y- l2 i. O0 }& _+ j                   printf("opnd出栈:[%f]\n",a.data);
- m9 Z+ w0 ~( h4 C                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
! j! A0 ^6 f3 L                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
4 K! `  f2 g9 k  _/ k                   printf("结果入栈:[%f]\n",opn_tmp.data);2 g# X5 t6 D# t7 b, M
                  break;
+ l: S* F: X) w/ ?          }, S1 Y0 `6 _4 U/ z% Q$ X8 \% o+ z5 X
      }3 Q8 ^4 \6 c% r( _+ d
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
7 @1 H9 `( x, O, ~# ~2 b7 A; ] }( n" t! o1 T, L" \; R5 M4 p2 W4 w( `# M
GetTop(opnd,opn_tmp);
2 |# n5 b$ Z: @ DestroyStack(optr);2 s3 Q  \2 ]3 ~( N; s% T6 s: g
DestroyStack(opnd);
7 f, A/ S5 |; M. e return opn_tmp.data;/ o3 q6 n0 B) ]. r+ J- j
}
4 J% {  e6 M3 [, m9 K1 b  Z
/ g' {9 V8 y0 c/ v" i' m1 H7 Rchar *killzero(char *res,float result)
+ T. c3 i" U4 z2 _9 p( A9 s{
0 j! Y! u5 x3 M! U, [6 U9 ^ int i;
$ V! e$ Z2 Y7 ^: l  ^( ^4 l5 @7 C
# ?6 H; Q, e! i+ f sprintf(res,"%f",result);
% ]  g, T7 t/ i" S2 g i=(int)strlen(res)-1;
4 G0 J, n! T, {6 N) ^4 O2 t( z* g while(i&&res=='0')4 e% b5 G7 F. K, ~' `. Y
{
1 x3 c$ Z1 F0 [- B( W       res='\0';
9 q0 w! f; w+ `" ~       i--;
& F6 [+ w% N2 p3 k6 g! E }
/ C1 h. T; N% ~+ ^8 z2 G; x if(res=='.')
4 ^# l; Y( _5 M) O# m5 x" A       res='\0';
, @: n2 K6 z# X+ [ return res;
, V7 n' [1 K  X/ c1 h, f: S}
/ ?2 n; [% w6 R* }1 _1 \- B( }; b/ l/ b+ c% M( A7 `) H9 S! H9 {
int main()% C* o9 G+ i% ~- @+ [) O# w& p* G
{- F+ b* O; F0 E) J, |0 Q
char ch;  F5 @  S' I5 I
char res[64];. o. H# \4 I3 @' C0 ^& G
float result;/ F4 `! ]8 A: H, Y5 u
while(1)8 C' ~* J; J2 E3 G& H/ f- v
{
3 `; B5 R: S9 G- p       result=compute();
; D% i1 u& a% h: R0 j       printf("\nThe result is:%s\n",killzero(res,result));1 q6 F, w! ]; ]* t# }- S! q
      printf("Do you want to continue(y/n)?:") ;" I# m* e7 K5 Y, }( J7 ?
      ch=getch();( F+ U% p6 E% s
      putchar(ch);6 V) D  L9 m3 Y( p& S1 O& t9 L
      if(ch=='n'||ch=='N')
- a, v  @- ^3 M9 Z0 ?7 X          break;- [8 A! X9 G9 e+ h& c# {
      else
: L5 ]2 H3 w* a: }$ ]1 Y$ x3 `3 k          system("cls");$ O) G+ U* W# ]6 E
}# y9 Z/ [  F0 {
return 0;7 \1 M: ~, X( y/ v! ]+ T# J3 I
}- k: ~8 @. X- v, c/ X2 V5 r
/ Z+ ]; s  U9 _8 g  n% P
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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