C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=. |' \" G# R+ @! T/ U
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>$ v0 e2 e' X! M, r
#include <string.h>
#include <conio.h># k8 ^! W8 l9 U! T
#include <malloc.h>2 A6 B% _# W% D; B5 M  P4 p
* b$ x9 G9 J0 B2 V- h) y+ q$ g
#define STACK_SIZE 100
#define APPEND_SIZE 10
: L( r# Z& Q2 P) w; O2 e
struct SNode{
float data; /*存放操作数或者计算结果*// j, h6 n: e. G6 ?
char ch; /*存放运算符*/6 c/ l  ]7 R% R$ ]- T
};' I, O' N. K9 O0 O
* F5 g6 a) @. R0 T' q$ j! D
struct Stack{( G! v% J1 ^& M& F9 h
SNode *top;
SNode *base;! `( c% u+ z8 y5 b
int size;
};( Y4 C5 r( ~& O- P' h0 c
, _& V$ ]2 M) [, K! w( m, a
/*栈操作函数*/! M" G0 g) \! G9 C$ E# j0 J( p
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/' P& M* b. m" b0 _1 T0 n0 m
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/  W) H* Y3 X5 K, y! ?5 z9 Z

/*表达式计算器相关函数*/; b4 o/ {$ g. J: c$ H# G
char get_precede(char s,char c); /*判断运算符s和c的优先级*/$ X. N( K* U& L# z$ W0 q9 u0 A
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 9 H/ S7 O7 I  d7 y/ P( P/ u8 r
3 ^; [( R' J# E& ~( b" A
int InitStack(Stack &S)
{: K0 E% j& D( ~, Z
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)3 F' D6 T. l: B* E2 b+ \
{
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;+ A- V  w% [. y4 T/ c) c) q. t# ?& k' @- |
return 0;3 ?5 X. z% N. h5 l+ P; Q' K7 R
}
9 m2 r2 a% ^0 I' f# ?5 `
int DestroyStack(Stack &S)
{
free(S.base);4 G: \8 K1 V1 H9 x4 K2 v
return 0;
}
+ S% r( h  v  C
int ClearStack(Stack &S)3 A+ j* v6 B& C1 ~. ], p6 E- v4 V
{
S.top=S.base;0 \/ Q+ O8 N6 T# S; L* \5 F# A* ~
return 0;/ o: ~5 x$ a! D8 {& j
}( P$ u4 E$ {9 G8 @& I( u4 e

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base); J* l; x. j; _, S  K
{
      printf("栈以为空!");
      return -1;
}, \' h: \- @* c2 |5 S# j; l  B
e=*(S.top-1);
return 0;
}% o% n2 l" M- C
3 \) r8 v% n2 }  a7 w% h
int Push(Stack &S,SNode e)( Q- n( z# }/ b, `
{
if(S.top-S.base>=S.size)4 K. ~* O1 k5 |% \% u+ ?
{, G# {5 c4 j1 S8 x/ [1 y4 O' n5 ~
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)/ s$ K# \7 A$ e- m* C" B' P9 H  `
      {" f- _$ t% c; q% z3 a2 |4 \/ x
         printf("动态分配内存失败!");3 }9 q: S$ z3 `# j
         return -1;9 q% ]' Q! ~! t
      }: |8 |4 a; R$ T" D, X
      S.top=S.base+S.size;& }8 x, O) O' G! H' u# \; M
      S.size+=APPEND_SIZE;
}& X9 t# |# G% u) z9 F
*S.top=e;
S.top++;
return 0;
}

int Pop(Stack &S,SNode &e)# r$ V& K8 H0 w, d% n# k- o( W
{
if(S.top==S.base)
{# }7 O2 R- H$ f+ X+ K7 t( S6 O
      printf("栈为空!");
      return -1;9 \  T/ v3 K- T, \% Y$ x
}9 B( F) _! h- ^, n/ i
e=*(S.top-1);/ _( q1 o' c2 \: L' Q" m
S.top--;
return 0;
}( x' B: M* c- f, O2 E
+ }) B/ q- A$ @4 n) ~( Q
char get_precede(char s,char c); U, e6 i( Q& w6 z, w7 ^
{
switch(s)
{
      case '+':
      case '-':
         if(c=='+'||c=='-')3 x: p' p+ R: _9 O
               return '>';3 j) [5 C5 E, b! X3 J% w
         else if(c=='*'||c=='/'); F) v# O& F: E$ g6 `
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')' y; l+ X+ U: S/ g
               return '>';
         else
               return '>';
      case '*':
      case '/':- F" S5 I( Z- Z& L
         if(c=='+'||c=='-'); z8 V2 h* L6 N% _
               return '>';
         else if(c=='*'||c=='/'); E5 n7 ~  \" u- {9 |
               return '>';
         else if(c=='(')0 J- B) n3 k7 f6 f' z7 P
               return '<';
         else if(c==')')" J$ E. P( E) f0 U: H# F/ V( V
               return '>';2 f* Z' h2 \8 n9 y% Z* t  P( S
         else! D0 |: G- u) W# m$ Y( y
               return '>';
      case '(':- q- c9 C  q& A( c: U
         if(c=='+'||c=='-')
               return '<';/ L5 q$ x# Y2 K& h( c& v
         else if(c=='*'||c=='/')
               return '<';+ v) X7 E, H7 _) H  o' F  v
         else if(c=='(')4 y  l6 a& ~+ ^8 A* G
               return '<';
         else if(c==')')
               return '=';
         else
               return 'E';- y1 |1 C% j+ V4 B( y" }
      case ')':
         if(c=='+'||c=='-')
               return '>';0 k4 r, i6 N; ~" M/ _
         else if(c=='*'||c=='/')
               return '>';+ x8 r0 q/ Q6 k4 J
         else if(c=='(')& Y$ z+ M# a( c) v* J9 a  e% S
               return 'E';
         else if(c==')')  Z! V; P8 I" U3 P( q: Q' U
               return '>';
         else  K0 r' i* h# z  Z  o' f
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';) m- J, L* l' q
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')& H, o( z. D' T# E) ^7 ^
               return '<';3 t/ F) \( N3 g! M
         else if(c==')')( c/ ~1 s5 X, p- j8 F; O
               return 'E';) Q4 F7 B, {7 ]" A
         else
               return '=';
      default:
         break;: l  c( p3 ?7 P5 j2 K' l
}
return 0;
}
. I* D8 o7 h( p) Q, {
int isOpr(char c)  |7 F1 m- S: k6 G: C1 x1 }
{1 ]7 N" \% K; o1 c  x: j4 `
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;3 U. |! j/ `! [4 o% N# Z, U
}
) z) _$ D" o0 W" k7 r
float operate(float x, char opr, float y)
{; Y2 e3 e2 }/ p# e
float result;" F8 q2 n! `! `; P, K* r4 Z) D
switch (opr)9 l( }, t7 |2 Z* z4 A/ S+ }
{
      case '+':
         result = x + y;5 D; y% E$ \: a' _, j2 @
         break;! Z$ Z- w% }8 b: f( n
      case '-':
         result = x - y;
         break;
      case '*':
         result = x * y;, G2 n# |8 d* e9 Y! @8 P9 C, R
         break;
      case '/':
         if (y == 0)
         {+ Y9 L4 H) g; o  \
            printf("Divided by zero!\n");
            return 0;/ |" d) I+ I7 d& X, B
         }2 q% V: s+ i# x5 a0 J! Z" S
         else0 k/ l- X4 ~2 J! ^9 k
         {* [3 R4 B! `6 E$ w# B5 P7 s1 s
               result = x / y;( i( u1 T5 d0 M5 `) w( q5 d
               break;& D3 ~  l) ?- j* K( R; ~  S
         }; L2 m: p+ q& J1 a
   default: 4 J. T+ W9 Z. v6 s0 J8 \
         printf("Bad Input.\n"); : n% x$ y+ l7 _; L9 e6 i, I
         return 0;$ l  D% h) }# P0 B" P0 }+ J: V
}
return result;
} & K- a) h0 |5 [5 V8 o. o' g
( M* }& p+ G. [: m% m" H
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/  M- g: y+ W, o9 V3 U- K/ O
{
Stack optr,opnd;$ o# K8 Z4 M9 z6 `( A8 |
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;. d, t/ |1 |) z% E8 M/ y0 P8 X
char buf[16];( z% W' i# N! }, E/ m5 }% k7 k
int i=0;) I* g3 |- D3 ^" l1 X

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/% o6 Q1 l. c$ q0 v4 t
memset(buf,0,sizeof(buf));, Q/ `6 ]0 {8 e) E
- v  F# y+ ]$ K' @7 I
printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();. U- _% r, L: [, l5 M" h2 d$ [
while(c!='='||opr_top.ch!='#')- q3 n$ k  B* ^+ Z) b
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/5 }6 C) Z& q( }9 H6 F- W+ }
      {3 w6 }0 k9 o& q) @
         buf=c;' e+ t, S( [, U8 d4 M: V2 o
         i++;# ]+ _/ w- _( `9 x" q8 N
         c=getchar();' H9 }$ H, T/ Q/ C0 o# L, s
      }
5 @* C* {7 c- ~/ l6 f* r       else /*是运算符*/
. u* R1 D$ W& p. y5 C7 `& f       {. b, [) D, \5 L2 l1 O; ?5 Y
         buf='\0';( H( C& Q0 z2 {) E3 O
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/0 j7 g" D- ]! R5 z2 l
         {
8 k$ p& Q1 o+ m# z% L                opn_in.data=(float)atof(buf);
7 J' `. |, B! H* A5 S* {3 R( L                Push(opnd,opn_in);
& S0 l% e  J+ _! H4 {( ^5 U+ u                printf("opnd入栈:[%f]\n",opn_in.data);- n: Q7 h" V5 i* y" e
               i=0;
3 F4 R- t+ @) n: C8 f' S' J                memset(buf,0,sizeof(buf));
+ o$ C8 Y5 r- s! R/ @          }
8 H# r& A. d' U) Y! Y          opr_in.ch=c;
% k# `$ W" L# y          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
% G5 N% t* ^4 b! _          {, L6 d5 @* p$ ?3 \
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
/ W' N1 Q8 _. C3 O+ I                   Push(optr,opr_in);
3 q$ I1 v; n$ a6 @5 X) n! }9 @, s                   printf("optr入栈:[%c]\n",opr_in.ch);, P  K: B7 S6 U& r
                  c=getchar();8 \% ]- H& O9 [, Z) ~7 ?! e* t) W
                  break;
. b0 o$ {: j; Z             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/3 D( x$ ^3 X( V5 s: s) j# U* d; u
                  Pop(optr,e);+ t3 V' r! l, T. Q
                  printf("optr出栈:去掉括号\n");- U+ k+ D1 u% X  n, n# N4 @
                  c=getchar();1 j$ b# v3 S2 L  X! |
                  break;9 q/ A8 Z6 o/ I$ W9 }$ ^; }" y6 V
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
- \8 t' z1 ^; G" A+ _! P5 G                   Pop(optr,opr_t);
( t: o) U; H1 n+ ?' g                   printf("optr出栈:[%c]\n",opr_t.ch);
, r; w8 ~3 [1 }$ h, @& W                   if(Pop(opnd,b)<0)4 |5 @5 Q7 P4 b/ j
                  {$ V( I' F1 c& r! d+ c, T
                     printf("Bad Input!\n");
! U8 S4 i# m( Y% _                      fflush(stdin);
$ Q, e/ `% O$ J: w9 q# S                      return -1;
8 p% a% q* s6 Q' f+ o( V' J: F$ g                   }
! {6 W/ g3 M. Z# z% @* u& w                   printf("opnd出栈:[%f]\n",b.data);
5 ?' X* J2 X" e                   if(Pop(opnd,a)<0)
. M; b1 c( |) G0 Q1 Q" f/ ^                   {" I! A5 @% x. v: B) A
                     printf("Bad Input!\n");$ A; Y2 T# D9 r  d' J2 P
                     fflush(stdin);
# E3 v! o5 l" ~. P8 V5 \5 e9 l                      return -1;8 I1 \) T& v! {8 X
                  }. j! G" ]; s( T+ j8 A
                  printf("opnd出栈:[%f]\n",a.data);
5 g2 \, Z( G' [8 ~2 |                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
7 A6 m3 I0 b. K9 X* I                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
( T5 P5 x( c) j' Y+ [                   printf("结果入栈:[%f]\n",opn_tmp.data);
; _  ]( J1 B9 k0 `% C" ^+ q; e                   break;: [5 ^& ?( A! N2 Q9 b2 g/ f
         }/ C/ T+ S) R* Y( U. _4 ~
      }4 O/ m8 X% ^0 B7 m
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ! ~: n0 P  Y% _, {
}
/ i3 D  a9 a: r7 V" E' f5 D9 h7 F GetTop(opnd,opn_tmp);* p" z* m0 Q% I$ x) R  [" C1 F
DestroyStack(optr);# s% q% x' E- e0 `! E% i8 @3 U! i
DestroyStack(opnd);
# p& d! H& n# R- H- m/ S return opn_tmp.data;" r# A1 D6 m) L. k' E* X8 ~
}$ X  }# _) Q- E* [# |7 U- E) i

/ c" ^5 q0 C$ h" Ochar *killzero(char *res,float result)
, u2 i- T  T& f( o{
/ Q' H3 ^6 J2 G; P" z0 F& i. t( z int i;+ r+ H6 h0 H$ K5 \( H

  m9 Z. T# Q# e& A% N# a sprintf(res,"%f",result);4 }  E6 M8 D# F8 n
i=(int)strlen(res)-1;; q( L$ s* \$ I
while(i&&res=='0')# Z" g7 i/ X- c% C3 I  Z- C6 h) p
{
: s8 Q4 z1 \3 h; Q: d' t       res='\0';
* K5 A( A- [( M& s: d% f       i--;
, z& x5 m" Q5 } }
# S. s7 @  @: u4 l' r if(res=='.')
; c6 z- l" ~( r0 A       res='\0';3 u7 ?7 i8 u- P$ t1 Y! G/ N
return res;" D  e  O( C" c6 ^3 }
}% a  ^0 t, |% Z" J- P, C3 B- N
( g0 s; ]. E! q% y4 [! }
int main()
! z& c& n! n/ X; N6 J( V% Z- o{
0 @& S6 f& T& q+ s char ch;
: q; Q; @$ _" M% r1 F char res[64];
0 `4 ?& Z! v. P/ W* Z float result;4 h1 [3 Z9 U3 C
while(1)2 t( N7 Q6 }# ?6 t0 R2 L
{
' @9 p, }$ e3 Q; |+ w* q       result=compute();
8 M) m  k$ w. a+ m) G' {5 b$ r       printf("\nThe result is:%s\n",killzero(res,result));& ]  b9 M4 I/ b8 K
      printf("Do you want to continue(y/n)?:") ;; [. J0 @3 @: f9 d0 d8 }; y
      ch=getch();3 I( o8 ?( b1 T0 [
      putchar(ch);' Y6 F4 B5 l; U& e% x; O
      if(ch=='n'||ch=='N')8 q4 L* ^9 B3 U7 u1 i2 X. d. {0 a
         break;
9 T9 k  y1 F) t! z) t# \       else
! {6 h8 N/ R! d/ Q% x' E          system("cls");
! H1 ~% E2 B# K5 p, u1 x$ y8 v }
3 r' Q2 i2 G4 _5 _5 J4 q& J- L return 0;# l8 |- d  Z1 f! s$ M5 a" C
}

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

返回列表

C语言表达式计算器

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

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