C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.$ [( ~$ |* k( c+ X4 ~
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=/ O: }4 S" K# h  O; [6 x, P
/**************表达式计算器************/) u, w# d. R- r8 P, T5 ~, N
#include <stdio.h>
#include <stdlib.h>3 K: |/ D4 {  a6 F
#include <string.h>' U  D9 k, x6 M8 ~
#include <conio.h>" u) Z# g; E' J" W5 l
#include <malloc.h>) N+ K- O# H$ V2 l3 O1 P" I$ w0 w
3 c: l+ r2 K, T! J& N7 ]" g
#define STACK_SIZE 100
#define APPEND_SIZE 10+ W! e4 f8 p5 l8 x' `# k& y* t- g

struct SNode{/ r0 L4 W, y: f1 p
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};/ l  F3 V- c6 H1 K
% ?* ?  `1 D* J  W* @9 e6 }  Z
struct Stack{+ c0 Q# J: Z1 `2 V) D: u, A5 ]
SNode *top;# ^& q, g. P5 Y( E6 |* ^  j
SNode *base;5 [( Y$ U! a* G9 m! m
int size;
};! e3 R! a& Z3 A; u  T

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/6 H. s* Z) l0 r+ o/ r
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/( e9 K/ w! f  ]" A- I, C$ m5 i
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/. {- ?0 _0 F) k% X
int Push(Stack &S,SNode e); /*将结点e压入栈*/4 K: p' a: w+ {4 O; d
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/0 H# y; O6 Q8 E8 l
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ % D" H/ ]! O2 @' N+ J
; E. Z" |, z% ]1 g* T
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)! G9 J1 F( a9 V# }9 K5 T
{
      printf("动态分配内存失败!");" J2 f  m1 @, R7 `
      return -1;
}4 k/ R" b- b) y5 i
S.top=S.base;( X3 a" T/ p1 }+ g* ]; f
S.size=STACK_SIZE;1 L# M7 y) j, R6 v# u
return 0;
}
! d$ V" G$ R3 z1 k0 ~- B& n2 d7 A
int DestroyStack(Stack &S)$ S9 o% J) U# A/ ]
{
free(S.base);
return 0;: z& @2 Z+ T! r; ]& `: o
}; ?, [/ q; T9 _" }( Z/ J- p! f$ C

int ClearStack(Stack &S)2 a& ~/ d4 \/ r6 }
{4 }$ Z0 r. j+ F' u/ A
S.top=S.base;
return 0;' ]! N+ R& [/ i! `
}
2 D$ a/ }& P1 `4 L; k
int GetTop(Stack S,SNode &e)- d3 |$ b* s3 W, r6 y. F2 F
{* K& q: r; k  W# t! S
if(S.top==S.base)! v# B" v1 O5 Z  T
{& p' M& O$ i5 d3 h+ m1 a
      printf("栈以为空!");8 u/ y  ]4 V7 _/ y: S, I7 ]
      return -1;8 F& R2 G* ]- N
}
e=*(S.top-1);
return 0;
}

int Push(Stack &S,SNode e)
{: J2 s! e. ~! ?: {) B) V
if(S.top-S.base>=S.size)
{' _* E6 S$ g; y2 p3 o- i
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));3 T' a2 w. c! i! D& t$ s
      if(S.base==NULL)
      {2 j% x( M1 T4 K! {" x( p
         printf("动态分配内存失败!");8 Z! `: f( v/ q- Z# E. ~: u3 |, r
         return -1;
      }
      S.top=S.base+S.size;" W/ A3 z* U# `* g
      S.size+=APPEND_SIZE;
}
*S.top=e;6 e% v0 ?; F1 l. {; n' w' C0 j( \
S.top++;3 `( O* n- P" H# ?) ?- X$ ^
return 0;
}# J/ p0 ^1 E! S7 k  v1 |( ~

int Pop(Stack &S,SNode &e)5 J6 H: I9 p1 y& B0 R
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;
}7 B: L2 {2 x6 i! F; _
e=*(S.top-1);; v/ O2 w7 x1 E7 u1 v9 p
S.top--;. B7 \6 q/ @: m' V9 q  s" z/ l
return 0;
}2 d1 t: g$ X( ?) Y& w; [! F6 `% y& F
: A4 g0 I/ c/ n
char get_precede(char s,char c)$ }0 l7 [  S' B) P8 j; k4 @" G
{
switch(s)) T' w* N5 ^5 ]! D" \
{( }3 G3 A0 f# P/ P* z' D
      case '+':
      case '-':/ i! s% M( q2 z7 @, V6 `
         if(c=='+'||c=='-')0 Q& V# V+ f/ E; s
               return '>';
         else if(c=='*'||c=='/')+ q. X* s6 q' z6 d
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';/ I! J7 ^8 }$ a0 h1 w7 @. R
         else
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';9 D" S$ @# m+ V: V* \1 u0 w5 Y0 M7 |
         else if(c=='*'||c=='/')
               return '>';3 n% Q% N# L" X
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';7 `3 H& x3 t& n2 u
         else
               return '>';- |. A2 |# ?4 k
      case '(':0 _# ~6 Q7 R, }, F1 p7 G
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')6 }6 W0 `+ R( }
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '=';
         else+ P. J! R) ^# x5 M& |% K3 m
               return 'E';
      case ')':
         if(c=='+'||c=='-')6 H. h: U8 ]. V$ I% a- d
               return '>';: X( D; |5 |9 b) x; L. Y
         else if(c=='*'||c=='/')# j" r7 i( ~# Y; O" P1 V8 F+ X7 N# r
               return '>';
         else if(c=='(')
               return 'E';
         else if(c==')')
               return '>';
         else6 S4 {" Y- b# W4 Q/ j; h
               return '>';+ L& |7 k; a5 Y) N4 K& a$ D
      case '#':
         if(c=='+'||c=='-')
               return '<';' L# t6 C" [% @9 L+ E; n* J0 M6 K# \: L
         else if(c=='*'||c=='/')
               return '<';/ {* O' v/ J' h. \7 W3 e  X/ g
         else if(c=='(')
               return '<';5 b" K2 o& ^/ G- A* U: S
         else if(c==')'). F! ?/ p* I" I* J6 l* Z! X
               return 'E';
         else3 X# l4 O1 h2 r
               return '=';
      default:
         break;8 W1 _  \1 S- i, r5 c/ s" F2 _! X
}
return 0; # I7 i% t- F5 M3 g! k0 I+ ^
}

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')- A& P! b! ^- n
      return 0;
else ( z  c1 u9 d) r' v2 w+ R2 n
      return 1;, d% F" @( y5 o, y; p) Q) W4 X
}5 ~' S3 u' w* z8 V- l4 z" X. T& Y

float operate(float x, char opr, float y)7 A5 p6 p! k2 g3 k- c. F
{6 \3 C: K% {6 \& E# n2 v& S. n2 c
float result;
switch (opr)
{8 A( ^7 C2 t! |" f
      case '+':
         result = x + y;
         break;
      case '-':
         result = x - y;# `) o, y1 @5 C0 h: c/ H3 T% \
         break;! N/ m/ B' Q. P9 i$ `
      case '*':
         result = x * y;9 T* e5 T4 t  i
         break;
      case '/': 1 I4 R7 ?9 D: R' M' x$ Z9 m) Z
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;
         }
         else
         {
               result = x / y;
               break;+ i5 y0 j# s- Z8 w: R
         }) a; e1 }# g$ Y! u* ?# T. ~
   default: + ~' A4 J" _7 u. g+ I* d( @5 }$ f
         printf("Bad Input.\n");
         return 0;0 s7 P, I" k0 C( k
}
return result;) z: _0 q  a1 @
}
: i) ]* H# g% X- O# U
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/, p, Z  Q! Z# B; N( T* V$ G
{
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;
) J% y6 i1 t$ r3 H* m
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");' Y. C& e" N% F, u8 L

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/% h# }( T7 n. I
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')1 o0 T5 Q0 L8 Q
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/( L5 Y* w; q; F. C5 m
      {& H( A0 r2 \6 W7 `2 _/ s6 L6 C
         buf=c;
4 B0 b; O3 y) O: ?" v+ g          i++;8 z1 F, N$ {% B6 s1 E. A
         c=getchar();! b( L& d; B4 [  u% u8 ~! r
      }
) C6 N) J8 r2 N5 \' x       else /*是运算符*/
! I/ n/ d8 X! V0 G       {
- j: w$ g+ }+ z2 K2 F6 ~$ t          buf='\0';
6 m+ p/ m; [2 c6 f3 d+ E) @# }          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/( w) O1 `, E- }/ _2 x+ A! g
         {
- y1 g% n* s5 D. m3 ]6 p& g                opn_in.data=(float)atof(buf);$ A# t1 ~  f: }& I: b; I2 a; ~! t
               Push(opnd,opn_in);2 ^# F) V7 q) u
               printf("opnd入栈:[%f]\n",opn_in.data);
8 o/ G8 o; R/ w& P                i=0;
$ q; @1 [8 b. H3 P  w) ?                memset(buf,0,sizeof(buf));
! m  r6 p5 Y) z: F' n( M; f          }
: @" B. Y) v8 K3 M          opr_in.ch=c;
% Q9 M' K) j3 @8 a3 i: r, V8 v          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
- L& c2 {* D8 @, ?# F- C! i          {$ z& l  E/ n: S+ X' y2 C
            case '<': /*优先级小于栈顶结点,则运算符入栈*/6 _9 q& ~/ i! Z& c  J1 V* x2 G) l1 h
                  Push(optr,opr_in);
: G) Y: S% u9 j7 i5 i                   printf("optr入栈:[%c]\n",opr_in.ch);
. M& Q( b( `0 `' E                   c=getchar();
/ \/ S. M4 d7 f% F                   break;
) f. Q9 p2 R; D+ C             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/' ~) p9 @8 E$ L; n" b- g# m( g) H* V
                  Pop(optr,e);
' A; |' @# H' D                   printf("optr出栈:去掉括号\n");
% l# _+ b( @( D" i                   c=getchar();- T: E# r/ |0 b/ o  ]- v5 F- k
                  break;5 ?/ P: V: ^1 ~) D
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/* Z, Q3 k/ L; I1 m0 K! P( X# F& }5 y% [
                  Pop(optr,opr_t);
: o- `5 N( W) P" w                   printf("optr出栈:[%c]\n",opr_t.ch);
3 r* y* V, B; T! v; w/ V                   if(Pop(opnd,b)<0)
2 j  @7 {6 l- ~$ e: R( f: z4 }+ i                   {
) j( Z& |3 W) x* Q3 a  G                      printf("Bad Input!\n");
2 k) I/ w6 c9 j6 v- n                      fflush(stdin);
" h& c4 P: Y& I; I                      return -1;
; r9 E9 G0 Y2 x4 h8 Q                   }
% A5 ~  u3 D, t1 P" i  }7 ]. j                   printf("opnd出栈:[%f]\n",b.data);
4 }7 i( [8 ~" R3 y; Y3 J- t                   if(Pop(opnd,a)<0)
. u; F4 \9 N, x9 Z. b; b/ \                   {/ m( k# Z7 w: W+ C4 W( ~
                     printf("Bad Input!\n");+ H% v  c' N% U) ^$ }7 v
                     fflush(stdin);6 l/ Q8 E" A- N% X6 `( ?5 |: q
                     return -1;# O1 T5 X& U" c3 f* m
                  }8 q" H. d, ?- s& P2 |: Z) j- U
                  printf("opnd出栈:[%f]\n",a.data);
+ t! C3 [2 U) a; F                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
  O% l8 ^: `4 Q- k! `6 D) Y5 o( ~                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
$ A! F# c% Z/ d+ l; Q7 ~- q2 R! [' ~                   printf("结果入栈:[%f]\n",opn_tmp.data);
, x4 {# E0 D. x% R6 p( x" N                   break;' g* `1 b8 y/ r* o7 j
         }
3 d7 m9 n& y* u1 U& [0 Z- o       }$ M5 F2 y5 q3 r$ ~. I
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               \6 F- b; k; R" i* Z/ A* c
}  t" n3 l, j/ K" |4 g6 o% i* L
GetTop(opnd,opn_tmp);0 U# n( Y. k) i3 m' s
DestroyStack(optr);
, d; G6 ^% l% x0 d: B8 r; Z! y DestroyStack(opnd);- U5 Q( i0 w- N
return opn_tmp.data;* d. f- b# {2 s0 i# T2 \4 Q$ t* R
}1 z" R. O& D% H9 O( J) t! x, B

5 h. T* X, v# x5 ?char *killzero(char *res,float result)+ I; A+ G3 q$ S  c6 D7 {& R2 |
{3 O0 F$ x" f3 H& J$ u$ R
int i;
! F1 e; }7 H8 n7 ~3 [9 P( g$ l0 m' X3 G& x4 Q- z* w$ ]0 @
sprintf(res,"%f",result);
- t" C0 c9 I: k- Z! Y( b i=(int)strlen(res)-1;
$ p; {+ x) n2 }* X& d- g while(i&&res=='0')9 Y0 T  ?1 F# c' `& {, z6 j
{
# V* G+ [: e: ~4 j+ O6 l- c: H       res='\0';
& h. Y( j* X2 J+ v. O       i--;$ q9 ]- j$ A' |: w& q/ a) |3 m
}2 S. ^7 }% d' r! Y& a
if(res=='.')0 d( S! v" L8 ?  E* @, `
      res='\0';
. b) w3 G2 i8 R% b9 D1 w return res;; \4 {' E8 d5 I+ P
}2 E/ J* q0 K0 C+ J2 P
. a# C$ N' ?3 ~
int main()) o$ C- p8 h( E  E
{
. O6 f- z' [" U' E' O, J8 Q" Z' P char ch;
' O. m8 Z3 e6 F0 ?* g* t char res[64];; K% D' d. r( X' N0 o
float result;( w% V/ x$ E8 r6 ]. [: Q
while(1)0 v: \# r! y2 \3 E8 A
{! r( H6 a" m' H$ I  e$ m1 M  T
      result=compute();5 p: y$ ]6 A9 l3 d1 k0 W4 h: _
      printf("\nThe result is:%s\n",killzero(res,result));6 ^' r' t6 F8 U7 l/ n  i; `2 ]
      printf("Do you want to continue(y/n)?:") ;$ ~( e( {  [8 b' a) D2 f
      ch=getch();% b. p. \* @- O
      putchar(ch);
1 L( q/ Y7 y& d, y       if(ch=='n'||ch=='N')
6 ~3 K. N8 r3 E; x1 F          break;; h1 s+ l6 E) f7 d
      else
( }+ E! ~6 b1 H/ n5 A; w          system("cls");
, H7 e* N: L2 ]  l( X6 y: s }* {$ `& w. [5 n+ K9 O" X
return 0;5 Z. _, m( T0 O" \, D/ K8 f
}

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

返回列表

C语言表达式计算器

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

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