|
  
- UID
- 133
- 帖子
- 51
- 精华
- 1
- 积分
- 186
- 金币
- 55
- 威望
- 2
- 贡献
- 0

|
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
' X$ J; E" y$ V! Y& }! x8 F程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)= w1 a9 i2 U; q3 m9 U; N
/**************表达式计算器************/
* u w$ j! n3 e" R3 d6 F& F#include <stdio.h>% s' W/ Y& }& {& n' y% B o$ H
#include <stdlib.h>
6 o' E1 c- s) `+ e! a#include <string.h>- v$ D+ w. c9 d4 {. j- X
#include <conio.h>
6 C( `1 G% [- | b4 `# r#include <malloc.h>) o" w% A& t0 _1 A# C0 Q4 G
' ~- D( E$ a; ^
#define STACK_SIZE 1004 j% y2 J5 \/ t6 Y2 J
#define APPEND_SIZE 106 @6 \5 J+ l5 t$ w& d( u! w
, T6 R0 V- T4 j; V2 O" s
struct SNode{
$ j, V. h+ V9 C0 R' M' r, m float data; /*存放操作数或者计算结果*/
% J5 O9 t0 k) ?$ G char ch; /*存放运算符*/
1 u5 t: t; [$ a& Z+ T: |};5 @* }9 Z6 c) }2 y+ b$ v6 m3 y" N1 ^
% U2 Y- I! Y4 l& r' o0 w! o+ Mstruct Stack{; Z3 L# Z& g: @( G# x5 o
SNode *top;0 y4 p- d! @0 [3 l
SNode *base;
/ Y- x0 J& h' p/ u int size;9 x$ h2 ?. n1 b% C4 t6 [3 c8 o! w
};
' C: `2 U4 v1 j/ T; E' E; S+ E X
/*栈操作函数*/
3 v$ Q2 n3 `* ~8 P7 |; c* Wint InitStack(Stack &S); /*创建栈*/ r- g% h0 S; o0 C% W9 _/ I
int DestroyStack(Stack &S); /*销毁栈*/
( G3 z9 g& l$ r' c6 ]( `int ClearStack(Stack &S); /*清空栈*/0 W5 A3 Q8 X% \
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/ D* x3 r8 A* d' r5 j4 K
int Push(Stack &S,SNode e); /*将结点e压入栈*/
3 S: l8 b2 ~2 l6 h; x' R# t' Dint Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/4 N, g" z- O% c3 ]% M. Y
! H# K# {: j U; `/*表达式计算器相关函数*/
4 e8 m# F* Y8 o# `) Cchar get_precede(char s,char c); /*判断运算符s和c的优先级*/
3 w$ }9 C9 U4 {5 X w9 Bint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
; j1 ]4 H2 b; s6 A8 W3 x% w) f! M+ Dfloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
9 q; V0 t. z" q. A$ P, Gfloat compute(); /*表达式结算器主函数*/
! T* K4 p7 p) {: q5 @char *killzero(float result); /*去掉结果后面的0*/
5 w; o: h9 a- c7 @$ i4 M" d9 j( D t3 w, _# J6 G# q# _
int InitStack(Stack &S); T7 f/ D( W$ i+ y/ Q
{6 m" L# G# I" I7 U% a
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));: @" X# M: ]& P7 `
if(S.base==NULL)
X8 g) G: D/ U5 ?7 s# l' Z {
& \- Z2 H# j% a: o! e! F1 ]4 b: i printf("动态分配内存失败!");
9 R, E6 g, A1 H# Q return -1;: f+ w$ t2 l- L5 w% E/ }1 B
}
& Q! E+ a/ {3 e* u* E, c$ D9 J. Z S.top=S.base;1 R. s6 f8 z. [4 s: C [
S.size=STACK_SIZE;" L% x$ X& R4 ]4 ^( Z% d; y
return 0;
* h# ^1 J w' h1 B}2 k* T& E9 m; ]$ O: y
1 E- `) {7 ~3 m1 I
int DestroyStack(Stack &S)
3 ^( x* l( }% v7 S{
8 [/ {. |* t2 q- i3 b% Q3 {! `3 T free(S.base);4 @: Q( e+ J+ @- n9 q
return 0;
; T8 I4 Y% k7 K}
: w i" E3 D9 z* U/ m& {, ]
! A: \2 ?9 a* i0 ]# s# u" j* tint ClearStack(Stack &S)
& x3 \' s! g; P7 p( y J{2 O3 | G. f4 C$ ~$ ^1 u
S.top=S.base;
. p# D. _8 t" m. S' }: a! {2 X8 p return 0;
, x, q! C+ o7 @% x2 [} R) T3 y# H/ L+ @: H m/ R
, q: S; ]; B$ v/ D2 }& _- \0 o& ^int GetTop(Stack S,SNode &e) _$ Q2 o" ?# a% [6 _
{4 M. v& C: B3 f! G( V- }2 P
if(S.top==S.base)
; T$ P7 T V! A3 `4 k {! R# [2 H( |/ b3 e. R! P3 c' E
printf("栈以为空!");' I" U8 S4 o* r2 m
return -1;* s1 A; _+ P3 Y) t6 @' a
}
! C- r' p$ P- i2 w e=*(S.top-1);) N! p4 ]# K p0 X9 n
return 0;2 w7 Q6 S, f% n; T# e, ]
}
* J7 s) b0 S9 Q; `, J/ G
7 R D" n* s* y# ?0 m. Yint Push(Stack &S,SNode e)" e! @) e# f4 |& \0 e' |2 [
{
& Y3 t, o$ t8 T6 ?/ m4 C6 E if(S.top-S.base>=S.size). a; X- y: [% G/ G$ o5 X
{
& j) |1 Y' N: t. {& d S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
* Q" C$ {0 \/ u# L/ b; @ if(S.base==NULL)$ G5 \. p* U2 r6 q
{8 y8 N9 p) z& X1 n1 f% v: M
printf("动态分配内存失败!");
) T, M- ]4 A& F+ ]! ]& h l return -1;
8 f6 J8 K% s9 A) _1 S. z }( A) r& \2 [) |* w
S.top=S.base+S.size;
2 W" K8 s- v+ R' l r. K S.size+=APPEND_SIZE;
5 R6 [+ f" O! m }
8 ^! ^# }1 p6 e6 ?1 c# w1 m/ s *S.top=e;: p" T( J5 R2 J/ o3 o2 A r. R
S.top++;
, x9 C5 f' M9 e8 b! }3 X return 0;
2 [5 p& t, E7 J9 _ w- f}
& F2 K$ G6 b; v/ W! y2 P. e. a4 O5 f, a0 X
int Pop(Stack &S,SNode &e)
$ z& d7 l8 q7 A8 x0 }$ | \{5 w4 L4 m1 \- }3 L% t
if(S.top==S.base)" q* R+ e# o' h! s# V) I! @
{6 u J4 `8 \5 p4 { ~0 n: ^8 Q- L
printf("栈为空!");8 r1 a2 |/ Z2 J# ~" O4 S
return -1;' G, O& I) }& A; @! B
}$ g }) `9 Y! o2 @- v7 P
e=*(S.top-1);
$ S q! ]0 ?$ E( j- W S.top--;
. p( z8 `# w) Q: x( c) C return 0;
- R! O7 ~5 F7 m0 `}
8 D. T. H3 T: o" O/ K3 F8 b, q* W W* d9 U6 p
char get_precede(char s,char c)$ g5 v [4 y% M: ]4 a" `1 b5 _+ O
{
9 v. n- o. l8 ?# P2 j9 a* R7 _3 R7 l) x; ~ switch(s)
: @5 x( I2 t9 G" U- m! ] {) ^3 W) a. Z" s
case '+': ) v9 v8 v! e7 x7 @
case '-':4 \! _' T$ |& ^ D# B: o; `% g) i
if(c=='+'||c=='-')+ {' d# L G- K* w
return '>';+ O$ z V: }/ q) _) Y. r- x8 N
else if(c=='*'||c=='/')2 g7 A2 E. |: {$ u3 m
return '<';+ h% Z n3 F7 n; x5 ]
else if(c=='(')
, e9 D$ k7 T/ _+ s return '<';
6 ^$ J* }# D4 T* o0 ^ else if(c==')')% a4 `$ O7 ]) s6 Y9 l* x& h9 g3 }
return '>';% b1 A- O( U6 O: {
else ( ?- M. W4 d: a, e. P! w
return '>';% s2 m$ M/ Z% `* w- n# f; H
case '*':# O, e% g/ \. m& y
case '/':
9 @, K2 a+ C: O" Y* E7 ? if(c=='+'||c=='-')* Z( |- f9 D: P& |. w2 T+ }9 Z
return '>';* c, C: `% ?5 p0 E- R; v: T
else if(c=='*'||c=='/')
( O; ~7 l$ g- t( V+ @+ K0 } return '>';
+ ^2 C& j) j7 a else if(c=='(')* g% D$ j' F; E8 ^' Q' ?$ o
return '<';
: d' B: t, j' h4 m& T7 ?3 L else if(c==')')+ d+ `' L) l1 g/ n
return '>';
: y3 @( h- Q8 y" K! C: | else3 @( T3 b+ ]; ]* Z* [- o$ B
return '>';
$ P! `2 U1 p3 L( K case '(':
( N$ Z) D8 M6 f* t$ l* s if(c=='+'||c=='-')8 D2 L9 x1 _1 E, ?
return '<';
- e0 ~2 P$ Q3 J% u2 a2 N7 S! g5 T+ |- B else if(c=='*'||c=='/')
8 X( ?( \9 q2 \. ` return '<';/ Y* N( z0 g/ x7 B. {# }
else if(c=='(')/ l8 N# C7 k9 b: Q! ~5 C
return '<';+ u$ [2 a3 l. p& f, [1 k l
else if(c==')')
1 e4 l# x' \* d8 Y& c$ d return '=';
5 P& f& U& l& ^% V D; l4 e else, P& C9 J+ s3 E# S, x
return 'E';
& N2 w7 d# F8 P6 K9 N! @9 F- f case ')':
% c+ O0 Q _% E1 k if(c=='+'||c=='-')! x6 s2 \2 c+ [! U( E
return '>';
9 U5 l) ]6 x ?, S; B- y5 N( M else if(c=='*'||c=='/')
9 j- {; [/ G3 Q* \! n, @/ w+ B return '>';. L# h: S, j3 B
else if(c=='(')* d9 k8 e* c) r: J: s; }9 C
return 'E';
! Y4 X2 K4 t/ i4 w else if(c==')')8 j% p i$ _0 G% V; L* o
return '>';2 L7 b' F, j) G: c/ ?2 r
else4 @9 V- P( ?2 \' j! D+ V5 ~3 m
return '>';
2 d# |/ T( h q% `4 ]0 O4 A case '#':3 v3 i2 F6 N& @& ^# `: L/ O/ [0 f! r
if(c=='+'||c=='-')2 i# \7 Z; g5 B0 u% W5 j5 V) I
return '<';
& ~& Q% T2 B3 P/ S1 I. y else if(c=='*'||c=='/')
; Y7 \0 a; U; `% U& K( ^ return '<';
4 m& f1 h5 z8 D0 m% H2 Z else if(c=='(')
8 R! _' p( B7 v# s9 W return '<';
/ [" e5 J, l5 s6 H S( o# L/ x- S else if(c==')')
* `% G/ |; Y, E8 [ return 'E';0 H& t9 `1 C1 j5 k4 ^; g
else
7 J3 @/ }: c, C) ^- S' k, U return '=';# e7 H# z( k5 H" H: U$ J w( t
default:- O4 G' g4 D# K
break;0 {+ u3 m8 \# k
}
1 q- ?% ] ]9 K0 _% s7 k return 0;
0 x" R" j! P1 p: i2 g* F}! d' K& s1 l& a: j( y
# V( W6 _& ?% Q; S4 I
int isOpr(char c)+ X$ V- O$ V% R+ P
{( J5 o) j4 r3 y- m3 E. q7 C
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
) O- {! Y$ [( S! B$ h! n return 0;' ^4 H% ^2 }7 A5 C" ^% M! ?( q
else 6 I, r! l7 s( o% r" c2 Q$ K, P
return 1;" y+ j9 T1 u3 x7 v& _
}2 m+ ?; l# O0 v) F
' y- G1 V( k9 g$ M S
float operate(float x, char opr, float y)
9 f6 L! c6 C) F7 U- V9 u{5 y6 Z+ T/ t5 \3 x$ b# T6 Q
float result;
- e# `1 K) H- J5 ` switch (opr)& [- a+ k% O# u' o$ |1 w$ ]1 `2 r
{' ^3 ~7 t; q' v& {# ~
case '+':
7 t6 u r: ]: J; ?6 `# Z result = x + y;2 `, P: {# l& m- ]. C. t
break;( R/ o3 s7 e7 ?
case '-': : d0 ]: Q7 H% Z! |3 H* C- i/ [4 E! h
result = x - y;
7 k8 d4 O9 [. S7 i) X1 Y+ ]5 E break;) r4 U; v$ Y- M/ L5 b* o+ W
case '*':
) s) M* i, z; Z1 s, n% d; h result = x * y;
" _$ U$ K) L T7 _5 X0 R6 _ break;( k8 _2 j( r! c0 y( G
case '/': # i* ^: e' l# ?( k5 b
if (y == 0)
& g3 K+ m, l, g! C( }) a {
4 N5 v# |* y5 h( j9 d printf("Divided by zero!\n");0 k: M- _7 M/ Z3 W; c9 b# h3 ?
return 0;4 e, p6 S1 B1 o# C8 F
}+ I0 R7 y/ V, ]
else
! W8 v1 S+ A6 B5 m7 j9 b7 m4 I- W- t {
6 Y2 o/ u: M+ O' G0 Q5 s result = x / y;# m9 w. ^- }3 @& t( i, r1 Z
break;* r1 c O4 N7 c3 y/ v8 f% g/ ^$ z
}
+ }4 z2 [( ]' ?, L; b8 [' G default:
* }. i, e4 x9 R printf("Bad Input.\n"); L% o r, I1 M r% i A- o) l
return 0;. y" S( r! o6 j# b& g
}' N! E& \- j, O; t1 s
return result;9 T5 ~- [+ i1 ]* J# G
} & [* ~% J3 R. O g, q, k) i' Z0 L
d5 Y: B0 w4 Z3 B8 tfloat compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
' {$ f9 C9 m- M0 J* N- T, x. F1 R{/ }- }7 D' q' {, F6 S v
Stack optr,opnd;
( y+ \+ \& R( c$ u& a$ P struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;% ^% s" c7 s2 N* F8 E
char c;5 _- T1 l* _7 D4 q
char buf[16];) }: u. Q& }) a
int i=0;
% I0 |& f, g f8 f, D : X5 N' t0 R, M/ W, B5 H* ~1 b
InitStack(optr); /*用于寄存运算符*/
9 J7 ]6 W/ T$ a) l InitStack(opnd); /*用于寄存操作数和计算结果*/3 K/ m2 r( n, D* L% }* E
memset(buf,0,sizeof(buf));
2 i$ M; p5 ~3 Q: k2 G
- a$ V1 q( n6 ]0 z7 l D printf("Enter your expression:");
" ^' j4 V2 T% G3 M4 Z& M1 c$ |$ W9 C 2 }; @; d9 c7 T# R
opr_in.ch='#';3 i$ [: D% w9 J+ `
Push(optr,opr_in); /*'#'入栈*/4 W3 Z& z& x I! _
GetTop(optr,opr_top);: b; N& E6 o$ Z# w) x4 m% M. J
c=getchar();5 y/ V) [: ~2 c6 U t
while(c!='='||opr_top.ch!='#')0 S! P/ v. ]" B* _
{! }% `) ^. S3 Y. M1 u2 w
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
! q( z- F& I6 T {
4 d+ c- J% Z$ K9 `; w3 [9 f buf=c;0 d1 D* H& x2 ?
i++;" d" t/ i) y6 H i1 U5 a
c=getchar();9 s* ?8 B: t2 e3 {
}7 f6 Y( @- y. p% u6 m x3 f6 n; q4 T
else /*是运算符*/
- U6 a- F1 v+ M$ `: Z( B1 {! q {( {* k9 t! ?+ {9 x) W* }
buf='\0';' K- R5 y2 u1 \2 ~/ ^
if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
6 J, u7 B! q3 J {% e. Z* ]/ b' M+ J: Z8 S8 N4 L# s
opn_in.data=(float)atof(buf);
h7 x" N! v( j Push(opnd,opn_in);
2 c: U% R- @, o q1 o- e5 v: b printf("opnd入栈:[%f]\n",opn_in.data);& ~$ d) Z; s T n& x2 d
i=0;
a$ }% I, @% g; G) r1 U memset(buf,0,sizeof(buf));0 W0 ]- M* I! |7 [- c
}
( O2 R6 h3 p' D6 d) W opr_in.ch=c;
% x' M4 I7 v# n switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
( c3 k( ^) h9 E0 k# O% G {
& X+ u% y/ ?( |$ z7 e0 w. s case '<': /*优先级小于栈顶结点,则运算符入栈*/
6 j5 W3 }; k8 G) ?' \) C, W Push(optr,opr_in);; K/ T: O8 W! L, V
printf("optr入栈:[%c]\n",opr_in.ch);
" h0 o* J8 Z0 V5 P7 v c=getchar();& {. H$ n4 E3 r" i( W
break;
2 j$ J" P3 ?2 ?* x case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/8 \+ ?2 O( X; M2 |! \
Pop(optr,e);
9 v: k( X8 i: Y printf("optr出栈:去掉括号\n");' o) h1 o, z4 U# S: w. q/ q
c=getchar();6 h: ]' s$ t3 v5 A0 r. ^5 L2 }
break;: x' |: m7 U) ~+ H, D/ H7 B ^* k% s( V
case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
* m; }$ W4 o# ?! i: I# A Pop(optr,opr_t);
" j- R- t- `7 N8 H" B0 I printf("optr出栈:[%c]\n",opr_t.ch);0 f: f8 c- {/ T
if(Pop(opnd,b)<0)( U: V2 `$ m0 i
{' c; N! L! ]; U( Z
printf("Bad Input!\n");1 |5 [1 G2 \) {# E
fflush(stdin);# R, \) n1 |+ G1 q
return -1;: I* ^- m6 ]' I" }, O
}1 U6 r) v; A7 D
printf("opnd出栈:[%f]\n",b.data);
6 V6 x5 N( `: a% a9 V. T& n- J5 h3 H" c if(Pop(opnd,a)<0)
" s/ O; i- m+ _& A% _1 t# ?# I {
; G' f5 h& Y6 u; U h. j: v2 e/ W printf("Bad Input!\n");2 Q5 }$ V9 x6 N9 A G1 E6 o/ e6 I
fflush(stdin);
+ `( N) b9 v2 _3 ~6 B return -1;
5 _1 m& {. h6 A& Q, ?) E' N9 C }
8 X& b6 s8 j8 L, j+ j& o: O printf("opnd出栈:[%f]\n",a.data);1 X7 H8 H( C. s8 x
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/. m; h' z, `) i, H) S9 {# G
Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/" f5 B* C. y% A+ H5 \4 y
printf("结果入栈:[%f]\n",opn_tmp.data);: E1 r* V8 `* y0 G3 m/ g! G& E0 G
break;9 {7 ?" M. s- Q& z3 |
}
/ f" I1 i! u- L1 r }
5 G; [8 `* `# q7 e. ?4 J1 Y GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/ 3 E- {7 ~! a8 o7 a% o
}
$ j8 G& S& k3 b( Q GetTop(opnd,opn_tmp);
- T4 w9 `3 u4 r& J8 I DestroyStack(optr);
4 }- V7 v, e k: E8 j" j n DestroyStack(opnd);
6 t/ X: q; [4 Z: O( @( h return opn_tmp.data;, P6 z7 n, ?* U. \$ g& I
}) x$ ^" j& Q! e+ Q5 Z+ A
1 l3 X& e3 u4 r3 z# @
char *killzero(char *res,float result)( E% b, ]; g9 Y/ {3 {6 i
{, Q- b; ^! ^! q3 T
int i;
& W5 ~1 o5 Q0 m G# p( \/ t' ]4 z5 o! W4 c/ n! H
sprintf(res,"%f",result);
; r/ V% `+ r& y5 H# C i=(int)strlen(res)-1;, T! c3 F, j9 a9 C, \
while(i&&res=='0')7 B; I9 q# k) T: \5 T# z: k
{
: j9 }. {$ I5 j$ t* o' _ res='\0';
% k/ y5 x& z K" n i--;
! p/ a5 d; {1 W" N }
! j7 J* `5 W4 M9 ^ if(res=='.')
, B u6 {2 m/ P' N9 j s) M* w0 p- ` res='\0';4 I+ i# j6 d3 ]
return res;
' F2 M- j ~9 L) P+ `}2 l) {' s0 l0 {" r; P7 j( c+ N
# U9 x. q2 ?7 L$ Y- E/ u0 \/ y
int main()
5 l& [# ?8 d1 c; A0 y$ A. |. B{: `# P1 n3 ], w6 C: \$ b4 p( S4 H. s
char ch;& Q3 r( M1 U( Q% a
char res[64];' } J9 X4 u% h5 ?/ d, x* P
float result;7 S" s5 K; O M) u; K0 h
while(1)$ `- l# d i( @3 V* X
{% c$ C6 {3 K5 r5 u$ W
result=compute();
8 X9 ?; v. \ O4 f, A+ i! T printf("\nThe result is:%s\n",killzero(res,result));; |7 Q ]# i# L4 ~( M2 v8 E
printf("Do you want to continue(y/n)?:") ;
/ W& R5 i" w& @- m$ a ch=getch();
; x8 n: o) W3 d putchar(ch);
+ e$ M& Q5 v& F* l4 |2 `. L( A if(ch=='n'||ch=='N')
* d4 V% ~; K) e5 n break;
6 }% o7 b9 s' ~$ ]1 l8 O5 J& ~3 R0 | else: ^1 k2 v Q! N; e2 C6 e
system("cls");1 t+ v* { O# X
}
9 ^, ~3 B* X/ g- S return 0;
7 w( f: W( ?: q" F}
2 o4 S4 u- h5 o2 t! H% c2 L7 |" A' Q0 x$ G0 a5 z, N/ a
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ] |
|