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

|
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
, z7 f8 a. a1 X1 i; Y/ W( c程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
# D5 }9 \: {# \/**************表达式计算器************/
3 x4 Y1 Y; `& F2 i! P#include <stdio.h>
9 O ^6 {; J% K# U: c$ M#include <stdlib.h>
) @ k5 l! @. ?' R# C#include <string.h>4 Q( `$ s9 \+ ?
#include <conio.h>
# e, |: V9 j2 _+ r3 @4 G5 Q5 s#include <malloc.h>' G* ~- r! x" u
i7 @7 u8 s4 G; ^" O* r" W
#define STACK_SIZE 100
4 i8 O" R* [7 a$ y) V#define APPEND_SIZE 10
; }. J4 A. ?. |# {5 |
9 c- X3 O8 N% R' o0 V4 bstruct SNode{ {* t& O: R0 ?$ N: ^9 U2 c. \0 u
float data; /*存放操作数或者计算结果*/- c% _! l, }8 Y! g* P
char ch; /*存放运算符*/
3 a, k1 @" g0 X, L};
$ S( b8 y3 A# l; e
1 o+ S R8 A" Dstruct Stack{
2 e: a4 l$ s+ R* a; ]1 v SNode *top;
" X7 w0 q' o7 D3 U6 B! V- H9 Y SNode *base;
' p4 p5 ?& U" q% s. D7 G1 D int size;
- F/ a8 o- t& m6 }};- M; g& U" m4 i) w
, N: Q( B# m4 d/*栈操作函数*/
6 Y4 H7 F6 E4 ~. y fint InitStack(Stack &S); /*创建栈*/
3 {& \$ F9 X/ a/ [2 [% L5 vint DestroyStack(Stack &S); /*销毁栈*/8 y% G9 a! G0 |
int ClearStack(Stack &S); /*清空栈*/' [5 z8 K6 j0 B0 x9 F
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
2 h/ @. I4 t6 I# y' G- iint Push(Stack &S,SNode e); /*将结点e压入栈*// p! ?6 Q t, |
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
4 ^- _3 ~) l o! N$ z" i; I, V. {( L. M
/*表达式计算器相关函数*// s' q& H1 {( g9 k
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
/ L' U6 S+ F7 hint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
" \0 n4 G* J Ffloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/$ ^# l! N3 V) j- ^& f) V
float compute(); /*表达式结算器主函数*/
% S8 m; Y4 d) x: S3 J) Hchar *killzero(float result); /*去掉结果后面的0*/
' A& M- ^/ H. v$ ?$ `! J) Q i9 p. X! ~$ Y1 q# o: s, Z
int InitStack(Stack &S)
5 Z# `' ^3 }+ N{7 j3 I3 t# K# l) J/ @4 {# n. t
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
0 w% r- B# m7 L2 B7 u3 P% f if(S.base==NULL)
8 Z! A2 M/ t$ N {
- m7 U k ]1 l& D3 Y/ ?- Z printf("动态分配内存失败!");
6 b, C1 P7 Z2 `/ w* y, t$ c3 C return -1;
P7 c. G! k0 r+ e3 F; M4 _3 ` }7 Q( ?3 u+ \- y+ k# Y* S. v2 ?# A
S.top=S.base;- k* d% z* ^: G# N$ U
S.size=STACK_SIZE;- @& h: h, d" F- A$ W
return 0;- w2 {& s# h0 N) U
}4 ?* U" ^7 {) {$ Y, d
& N% o9 v e0 v' g' o& V, wint DestroyStack(Stack &S)
, q( D/ Q, c: Q* i9 T9 c$ G{
. s4 U: Q$ w2 A$ y8 v: j; w free(S.base);
0 g! L1 u& e& d9 k* e. A return 0;
4 H' ?2 t$ p9 Y0 n c}
% i7 e& q* M! G! P7 @' X8 y, k$ x5 Z! B
int ClearStack(Stack &S)
2 |- a9 v. M+ s4 b{
# G! P: X. g' | S.top=S.base;
% Y+ g% b; n( A0 a$ S2 _2 y. s6 L return 0;. b; y$ S" O+ w3 o
}
r* j/ T, O% A5 f1 E+ U/ @+ ^. H2 h+ A* \- ^" o5 h4 h
int GetTop(Stack S,SNode &e)
% v, o6 q/ e' G$ j+ I- O0 Q{
8 h9 T* b5 ]( J3 b5 u9 u if(S.top==S.base)
; _& D0 F: w* D9 D0 d+ G& c" z4 ] {
" w% O" w# G5 I# A5 m printf("栈以为空!");/ U2 B4 {" U1 V) a" n
return -1;
$ G) w* I6 u4 L9 i }+ y; ^* W8 c8 N9 v$ J6 }
e=*(S.top-1);* o" U7 O' i# F7 g2 ~
return 0;
# \% A) `" L v8 g% q}
1 {1 V( {" z9 l) s8 }% U# K- h0 l$ \
int Push(Stack &S,SNode e)
3 K/ _& Y7 ?6 b' w$ e{
8 ]2 a$ M8 m4 @" \/ E! W) x if(S.top-S.base>=S.size): H4 q$ d. _1 k: i6 q: F$ @
{
) o4 C% ]: v3 u _/ ]: q$ | S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
9 }& N; _: W; H7 g0 ]& e9 t, Y if(S.base==NULL)
& p- e& t$ [$ b, F. \ {
7 \$ u, N# l- \* {4 F. h printf("动态分配内存失败!");# l# g j8 Z3 |$ H+ Z" u- x
return -1;6 ]7 E8 {+ ?& E/ q2 U+ x1 g. p
}
7 V2 q1 v" x2 R( a; e S.top=S.base+S.size;
: {" ~* r m* U S.size+=APPEND_SIZE;
# Z! ~; C, L1 W( g0 Y* E) Y W }
* G8 l" ]0 Z$ C, k" V+ O- g *S.top=e;
0 U; z2 {, t2 f" G# P! q, y S.top++;
8 A: |6 U z" q. B5 @( D6 f return 0;
) \! v- S& _7 b2 i0 N}3 g* H7 X. o# l' H/ p) i
/ z/ |! ^8 r7 u Y: rint Pop(Stack &S,SNode &e)
1 E* p; `. T$ D7 `& i{5 H, d, F5 w6 ]6 B3 ^5 F
if(S.top==S.base)
; x- F$ }3 T) n$ r: V' f2 ]( y t {
J% D! K# q8 ? printf("栈为空!");
9 `- V# c% u" H$ C s7 x return -1;
H& z4 L; b5 ?) t9 k( @9 O }' q5 E& K5 x$ r; \
e=*(S.top-1);5 ]; C, z* ^. g# ?# c
S.top--;
: E: Q' x R( m( ? return 0;
; ]! X/ u9 e5 z' w' U8 T* N' g}
% c: U" l: H( j, w$ |& ]
, t# x+ E; _# {6 m# x* f& Tchar get_precede(char s,char c)
1 b) A: g5 Q& N- z{" s0 e& [6 C! m, h0 D p9 Z; k, @
switch(s)8 h* o: f( `. Q4 F- ^% U
{+ d9 @$ c5 Y7 H( L
case '+': / M2 m D! G, d) _/ h5 W5 E0 n
case '-':
- X% c/ ]# d; g9 |. }" f if(c=='+'||c=='-')
# G) H0 F2 f+ Q6 r; F return '>';
6 Q4 s7 p/ Q4 [5 @) c4 M else if(c=='*'||c=='/')4 `% v) s4 {/ D) A, X/ d1 G. S
return '<';+ {* l7 w, ^! L* S5 A% t4 d" C
else if(c=='(')" `/ a: B9 V i2 b% M
return '<';
! }( `, [7 ]! E+ z* A+ g- s4 e, l else if(c==')')
) w/ V9 z9 T3 Y) B return '>'; Q) y H7 c+ Z9 i4 ~
else
`. {, B0 E) I3 @/ i return '>';
7 S; E; Y, H% R1 Q+ P case '*':
* ]; R: \- B d/ z; N3 V case '/':
# h$ Y" h9 P( k4 ^6 \# E8 j' V+ k if(c=='+'||c=='-'), r0 x6 ], U' b" R6 ?, O& ]0 d
return '>';
/ W, ?; {5 D7 p' U else if(c=='*'||c=='/')
# }! R$ H6 b1 H: r$ f return '>';, X+ z; J- Z: }) S" |, H8 G
else if(c=='(')2 F5 E) S( f3 _. i' Q. t6 Z
return '<';9 h% B7 ^4 f% }8 {4 ~7 V/ Y
else if(c==')')+ Z; Z, z/ D. P- f
return '>';1 u/ |! h$ ]7 q
else/ j& E W: E1 m1 `6 N! O0 d
return '>';
& f" L- V# K$ |# ~! o( K case '(':! g" e8 [3 v1 J$ w6 P0 C3 y
if(c=='+'||c=='-')
5 X$ `& ~4 H* J' F5 }( d* p return '<';
$ A$ i J' ^; R" a/ v4 w, B! U' w else if(c=='*'||c=='/')5 R# Z/ A1 r! A: l
return '<';
' F K; K3 Z- p1 E1 p4 l: L else if(c=='(')
/ i1 w3 }* U# A& J return '<';
& F4 `9 ?- y8 b X else if(c==')')% h2 v% K: R" [( J0 S/ M$ u, P6 I
return '=';, v- r3 D" l$ J
else
; ~6 O; _) u8 I6 |4 y0 r return 'E';, R5 F9 a* f; r
case ')':4 k% R, y4 V! @" [# j' Z
if(c=='+'||c=='-')
3 L% L% X- p3 J+ Y% G return '>';8 Z# o! d1 t5 h5 b5 [" z
else if(c=='*'||c=='/')5 D' m1 x# O9 b$ Y* R
return '>';
" N' a2 Y0 t3 F- L) S6 K. U else if(c=='(')
3 Z! q& a z6 a7 o& C! g" y/ D return 'E';) i. @" _0 w" n8 [" ~
else if(c==')')3 g3 O% y6 F O6 R" n) d4 x$ }9 l4 ]
return '>';* R; x3 g, v: _" q- |. [; Q
else
' {; u w1 T& _5 s; T return '>';
" m, O* A4 G" B4 k case '#':
& m" F1 l& C3 ?) G if(c=='+'||c=='-')
% p- D" F/ _* K: ^) T return '<';$ \1 X/ \* q- ?" o
else if(c=='*'||c=='/')
. j6 w/ a5 @- ^2 U% S7 m1 Y return '<';
- {" B2 b; [5 `$ s& X- U7 `/ I l else if(c=='(')3 Z9 p5 f# q8 ^+ v
return '<';
7 ~& A$ D" K7 n. P$ U9 t ?/ Z else if(c==')')
4 D* x0 ], C! y6 q! G return 'E';4 h0 V* I9 Z! _- E. V
else
S4 K5 G6 R& @$ a' X7 O4 w return '=';
6 t9 l$ q9 O# C( ]/ T' c% t8 V8 Z default:
1 {8 K+ w# w; \# A1 @% r break;
( E! L8 W8 F% X( ^7 m2 q }
" X: f# j7 \8 i1 V; L8 w" } return 0;
% s4 }' O6 k4 |}1 D% O+ J* x' y
$ U2 q: W+ |0 q8 }3 N/ W
int isOpr(char c)1 [$ m6 d+ F, w M# m6 a1 C+ R
{
7 [3 C, G9 Z; k% g/ q8 c* F$ O- y( c if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='='), H+ s/ B/ C! F9 s' R( _
return 0;
% N( H! S, ~1 d) R else " V! U/ R$ T! i. g) T, Z4 ^
return 1;4 J3 L" e! N- H
}: Q* f4 w% U' G. H, t7 F
! M9 @' D' U4 V8 K
float operate(float x, char opr, float y)
! Z& i. L8 A0 X/ q- C! G2 M% R- p0 N+ H{
1 W- F/ Y W0 r# b/ G) P float result;
. ~& R4 t) {9 V7 p' c switch (opr)/ \0 q6 U7 u8 _" w8 L
{8 a7 F. s* v) k
case '+':
% y" O/ I. X( b- x8 @3 B result = x + y;: s$ Q9 | W; Z
break;
4 \& j- i" K7 D! E case '-':
7 U& m. F5 Z& m$ K result = x - y;* S1 R( }. d; h4 p
break;/ p0 l7 i6 K. N# A8 R- F4 c/ P
case '*': " H v% }' m3 j4 n# L4 Z
result = x * y;" p1 G5 Z$ f9 n1 `" Q6 _* R B
break;
- u% u6 x1 Y0 P6 v case '/': z; S/ z/ |/ a& s7 ^0 V
if (y == 0)
& V2 q6 d3 T$ g5 R( u {
2 b4 q3 h) C* X7 N printf("Divided by zero!\n");
4 t$ S& ?* o4 W- ?; f' O return 0;
* R+ e, l- G1 _& _* e* H' W }8 t! Z6 K$ I7 B3 \/ I& }
else6 H" n$ ~( b) ]* k9 t: A, J: z
{$ x4 a+ n9 `4 M1 L/ K( s0 C4 @* l
result = x / y;
- a# r* h+ H' I, J) C# z% T break;# G+ t5 }$ J, z. E% h# H8 `7 l, R
}
, m# U6 l* u& N, ]5 y default: 5 G1 k+ \: P& A8 O4 n, t
printf("Bad Input.\n");
0 S/ R) U" G; } X9 e( E. ] return 0;
8 L+ F# x2 a1 N& \# {1 g) [ }0 K; a1 @8 W! R5 y' N% ?5 p z
return result;$ K* \2 F( p" @( K6 U8 [4 f! |3 W
}
4 D$ j$ F4 ?+ D n$ Q2 F8 k9 B- H; C* @6 M% F% P% I
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/: o$ W% m! h9 _
{. q2 J p/ W3 d) u
Stack optr,opnd;
, C+ ?' f: w5 J$ W$ `' b* S struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
! J; R& f2 i& ^ char c;
9 J$ z8 E [; ^$ l7 Q% V0 p char buf[16];! _' X1 a/ C- r- w! M2 g$ o* W
int i=0;$ K0 ^1 t" v4 `1 f4 [
/ S& v" i) l3 S1 y1 ?- M* E. A/ h& E InitStack(optr); /*用于寄存运算符*/
0 o; J2 D! z6 t$ U, V* N% p! y; k InitStack(opnd); /*用于寄存操作数和计算结果*/
& q8 S: [+ m* e7 E. C5 s memset(buf,0,sizeof(buf));
3 `) b* P/ q1 v+ X5 G % o6 X( B1 B- t0 P+ v" l
printf("Enter your expression:");
e& _$ E2 ?& M4 {
7 W6 X B3 O O# ]' }2 D opr_in.ch='#';
' @( B# G1 b! a0 J Push(optr,opr_in); /*'#'入栈*/. w6 r/ [3 y, l0 a) [) r- E( s! y
GetTop(optr,opr_top);
5 R& G8 y0 c o c=getchar(); a7 g1 W. e( o' g1 \. A I
while(c!='='||opr_top.ch!='#')
6 E8 b; {* B2 J, h. [* t {% q* X. B$ k! h2 @7 [* ?$ {, j2 {% |
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
Z; _" ^3 Q: X {
1 {# b8 Z$ l8 b buf=c;% P$ T7 R0 f' v9 b3 g. B! h
i++;
* Z1 c+ c8 m/ h1 A( b c=getchar();2 k+ X% L. ^( F p! Y- c
}
( K' @6 I# u8 [7 Z! d else /*是运算符*/% E9 G- f: i4 `8 @
{' M9 z. Q0 G" |- P' d
buf='\0';, O5 K* h2 u# M; Q" E
if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/- r7 N0 s3 g3 l* J X
{# g6 m" l$ d* t) l8 p0 o
opn_in.data=(float)atof(buf);+ \% J# A* m: P
Push(opnd,opn_in);# f( `, ]7 f( q! _! @) |; l3 R" S
printf("opnd入栈:[%f]\n",opn_in.data);- K: x3 K* W" N3 F
i=0;
1 h! C0 H5 q+ O5 T4 l8 Q) J memset(buf,0,sizeof(buf));5 G3 J* H9 |! _0 S- r- q/ B, {. B
}( |4 l7 ^, \; m) F8 Q
opr_in.ch=c;, f1 v( A8 T* t j7 @7 u
switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/; t _2 @* a# k' H3 p( ?
{! n2 i7 N! Q* L4 i: r8 g8 a
case '<': /*优先级小于栈顶结点,则运算符入栈*/
; G+ s9 Q1 m3 E- Y# g Push(optr,opr_in);0 w' I9 ?( L+ t
printf("optr入栈:[%c]\n",opr_in.ch);
% m5 r. h( C7 N" r5 L c=getchar();5 x7 z0 g% a5 J& j" k
break;
8 y$ ^, ^) M* m7 } case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/( T6 x: e7 a- a& k* l6 Y
Pop(optr,e);
+ B+ D' z6 n1 P( P9 o# |/ j printf("optr出栈:去掉括号\n");
! @3 r: X, O$ s8 l+ o c=getchar();
: _% F8 V) y F5 W break;7 i6 ?9 |4 `$ P, G
case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
$ e* h9 o1 _/ E: A3 i* J9 Q Pop(optr,opr_t);
; Y( ~8 c, F k0 H printf("optr出栈:[%c]\n",opr_t.ch);, `! e/ I. x, H' p$ O! j% I
if(Pop(opnd,b)<0)
! L% p2 w2 ^# Y! D4 | {7 x* P2 n" X5 f4 }" j
printf("Bad Input!\n");
0 g/ U, I; t0 z s# ~, _2 r fflush(stdin);
8 I$ R- j5 R4 F3 r( }3 j! [ return -1;
. d1 w, B+ F, F2 q' h, N; h) m- `+ U }
) _( H/ \; s2 S0 S/ `2 c) v0 v printf("opnd出栈:[%f]\n",b.data);3 K# T+ U: T& \8 Y& \
if(Pop(opnd,a)<0)% j3 i; H* q3 n7 Y* Q
{
7 E# S9 ?: {3 ]$ ^- A5 H4 p/ p printf("Bad Input!\n");" S# d* a" v- ]' Q& W7 q9 b
fflush(stdin);
0 F0 C# C6 C b0 Y: Z4 z return -1;; _$ H+ ^/ o; R* U( [, Z% [7 o
}6 f- P9 T3 ^6 K7 E" z( d
printf("opnd出栈:[%f]\n",a.data);8 {+ {+ g! h& A
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
6 T7 r0 K' \. ?2 @& r Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/; G4 T7 U c6 _* I
printf("结果入栈:[%f]\n",opn_tmp.data);. g9 o5 t ~* v4 ?; v
break;$ f4 _ I0 N) Y2 ^& d* ]
} P* V* f7 l3 h9 L7 ?1 p
}- |$ G3 o& [4 s: `5 j. C- e
GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
+ I$ H5 Q- Q+ o$ B }( ^# T& \/ `! x' S }8 G6 {9 n* Z
GetTop(opnd,opn_tmp);4 D5 i5 w! o( x) X v% v4 o& v
DestroyStack(optr);: Y- g" C9 F' Y) ^/ G
DestroyStack(opnd);
& \0 B- n) m; U return opn_tmp.data;+ ~! N) p* j2 K/ d" M
}
& I$ m0 N+ \: s; B: S1 r+ o5 z( G2 b% D2 r7 ~! E) e4 u- H2 d
char *killzero(char *res,float result), y) Y" p/ M3 Y5 _* i. |0 x
{! p0 |# f B2 B" ^
int i;
: ~6 Z5 x7 J, v$ F* L7 R7 g$ F( @/ Y( a
sprintf(res,"%f",result);
# x) O' _% z0 M5 j& { i=(int)strlen(res)-1;
# [& Z! X3 E& S o5 M# {/ x while(i&&res=='0')! u( z0 t" }2 o0 C1 A, c$ X
{8 U8 P% F# ?& v' ^
res='\0';
8 v3 y- N! N8 j* E. q, a i--;
' [7 o9 z8 T" c% g }2 u- m4 P* f- O1 U" b
if(res=='.')+ B( A( i2 \9 j# f
res='\0';! f k& L1 h2 p/ Z) N/ P
return res;' |: m& o G% u! ?7 l5 d& q& T
}. p: Q% q$ @! P' ]7 P
7 s! Z/ E- V% |* s( J8 Pint main()
+ C" \5 p# X; f: R! L8 g- d{
; }$ U, ?6 F+ @* y q. Z0 C; h char ch;
2 B8 ]/ d; P# z$ a8 w$ b k: v; v char res[64];7 @3 n( B: Z9 u: E6 r3 V
float result;
$ W( g0 c3 y7 t" D# e while(1)4 _5 L. X( b. X: [& o7 C2 u
{
( }9 M4 ^" w* F4 o! C result=compute();/ R' w8 w; {2 U0 t$ b
printf("\nThe result is:%s\n",killzero(res,result));
6 D; a _9 Q6 W. a printf("Do you want to continue(y/n)?:") ;
) k f' _3 ?8 n } ch=getch();/ [# F H- K" _. e
putchar(ch);
2 ]& m( C- F* L/ V if(ch=='n'||ch=='N')
6 [: p; h" J+ C( H. Y2 U* t break;
( K1 J) E+ } g6 L else
$ j# F0 B$ A4 l& E2 \6 ?) J system("cls");
j* P# B. T# q/ l# R a0 t }
6 W/ P1 m- J3 x4 i9 k6 R& v0 K. I return 0;
* z# u$ Q) S9 W}4 ^$ c% w5 b6 U8 X+ X
0 A D$ ]- P, m" F+ H8 N4 C
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ] |
|