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

|
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
9 t4 J/ C8 d# M% w* J程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=$ c! A- Y$ R+ U* {5 c9 M6 s
/**************表达式计算器************/
[" L' u( W0 e$ P#include <stdio.h>
/ E& ?1 x7 C; t5 q( m. p#include <stdlib.h>1 S7 O- \4 X6 c+ N6 ^
#include <string.h>
( z0 d; Q: `( h6 R# L- `+ A#include <conio.h>- }) U4 ]; j& h6 {
#include <malloc.h>/ \' ]6 ?: f2 l
3 F; A' q3 c) l! X8 s
#define STACK_SIZE 100
! Q( l, q, ]/ V5 B& _8 h#define APPEND_SIZE 106 m3 H: P$ n7 T" y
+ P) V% Q5 v1 ^: j" v$ Z: bstruct SNode{* p7 V5 t2 S, C }" _; O( ]
float data; /*存放操作数或者计算结果*/; T1 } M2 x, f3 O6 ^
char ch; /*存放运算符*/ q1 [/ g: z/ N' A
};( j6 V, X; e+ S: G. L7 s- h
6 ^% a3 l e0 O* ~$ e, astruct Stack{& ?% Y0 m7 x* Y1 g' k
SNode *top;
$ A3 H& M2 a5 d, p9 O SNode *base;" y7 }3 v! k$ t9 ~! F8 z) d) ]
int size; W Y; F% } w5 t2 p+ n& _7 ~
};; i. a1 [& Z. w
5 x! P* }7 Y3 |' F( c/*栈操作函数*/
( i+ m/ M+ B* s' Q7 o1 Hint InitStack(Stack &S); /*创建栈*/8 S2 W5 |# S0 S4 M. ^* \9 U
int DestroyStack(Stack &S); /*销毁栈*/
& H6 |7 B& x- X) F* yint ClearStack(Stack &S); /*清空栈*/) R1 ^( K* O, t& U
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/7 n% a( x5 t$ U0 h7 z) V6 c0 w8 O
int Push(Stack &S,SNode e); /*将结点e压入栈*/9 u4 B* T" }$ k! e/ ]
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/" R$ P8 G0 A& {9 X1 T( M% {
8 ]( @; b; {5 p0 f" x
/*表达式计算器相关函数*/
) k3 H+ n8 i. S. K. ^; I- ?char get_precede(char s,char c); /*判断运算符s和c的优先级*/
; H g* d) d Rint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/. }- |1 l; d' t. I# B
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/" N0 r5 @) W* P( a4 {6 d+ i9 o4 {
float compute(); /*表达式结算器主函数*/
* T# J6 A+ s* u' rchar *killzero(float result); /*去掉结果后面的0*/
- E1 c9 R. @4 X' j- f, B0 o1 `( D9 B, `* w8 A
int InitStack(Stack &S)
9 F+ ]2 A0 z" g5 i7 ?7 D# Z{
! O9 M9 l9 y7 Q5 m& P) n S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));) y' S8 ^9 l' a, ?
if(S.base==NULL)! `$ P( K& K( g, L. E* S
{
1 w* p0 U5 B" c$ S printf("动态分配内存失败!");8 s, i6 v, V% r$ {- j$ R
return -1;
! ]# b0 q+ H0 ^ }$ S- q/ K+ _& t
S.top=S.base;
* B+ y* j5 o( u6 c d S.size=STACK_SIZE;
5 o' J$ t+ ]: s. S" f5 j return 0;; y! n( l3 a5 B! q
}; X4 ?, z W/ X5 @* z. V" ]1 x
; g6 x- X" I% X7 t7 j, j
int DestroyStack(Stack &S)
6 q4 i# ]9 @7 e: d. w, g{
& I# k: h1 v6 h9 O$ e free(S.base);& W' V. i9 A: f* n+ p
return 0;" d) }" i) O! f# Q( z$ `
}" J7 J8 [% e" @1 F
; F" S4 T N& Y% B9 S5 t w0 k
int ClearStack(Stack &S)& b) R; A8 f3 e) @
{/ K/ A! V* W, _: {
S.top=S.base;# j: t) d+ z$ a( Z
return 0;( X1 A4 @) W" c$ j$ A
}! C4 G S# s) F0 S, ?$ Y
0 d e& U) v7 a4 T2 C
int GetTop(Stack S,SNode &e)
9 u, a7 ]+ J. K/ X- m0 H! G6 j" I{
/ c" `# m# _$ X5 y9 W if(S.top==S.base)1 M( d: `: }0 e6 w( ?% G5 {
{6 P1 Z! s G) L6 _) ?% y2 h( \( | Y: D. U
printf("栈以为空!");) q1 D- k% s5 w7 Q
return -1;
8 j3 u. s o# U5 h }+ `) b/ V/ N6 U* |6 X. D
e=*(S.top-1);3 }- V& r) O, |8 g3 Z
return 0;
7 N7 y; n& \& k- g" }}
" ]3 B- @: q! y6 H: t0 {
1 U v& A1 R# }' q. K/ ^+ Iint Push(Stack &S,SNode e)! r8 I6 W; \. E
{
: B4 e/ v( m [/ _$ a1 G4 A5 W if(S.top-S.base>=S.size)
( F# {' x8 G5 p5 L' R$ ] {: m. [ J) f% s6 c+ x6 W1 C- g
S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));' g% `4 K! y5 D1 M) m
if(S.base==NULL)
* l+ ^$ w% }- ~ {
: _5 N$ v; Q. c8 o" ^ printf("动态分配内存失败!");/ t/ B( [4 s2 {) _8 X6 Y2 B2 W8 X4 s
return -1;
8 W3 [$ m* `. ?6 b- c1 O1 {( W. { }: l& n0 g6 {& g2 Z
S.top=S.base+S.size;
% g* ?- P7 Q1 X" v) I# d' D S.size+=APPEND_SIZE;. y, Z- Z* n8 S. h8 |
}
, X: H+ V, f0 J0 J* U4 M- H9 _" x/ o *S.top=e;5 q0 }. j5 u4 m, ^9 O
S.top++;
1 ?" ^ U5 Z* F return 0;1 O# U4 `) U6 a& H+ t f+ ^* I4 {6 Y5 `
}# z3 Q) d+ Q- A. j, h4 f
! P6 {0 Z1 Z$ N2 Nint Pop(Stack &S,SNode &e)
& J" z- P7 p* X6 [, t" Y{& p3 G# {. f. x
if(S.top==S.base)8 o) Q3 s; t& J$ b) ~+ C5 Z
{% g6 [3 M" t, n; V/ ~, m
printf("栈为空!");
7 w/ F# J4 I) V: \ return -1;
- J' `0 s7 T# x1 o6 N/ ^. V5 ?6 U }
T% V C6 ~" J2 I# m e=*(S.top-1);7 A- R+ T/ G; V/ ~
S.top--;' j. U$ X7 v2 }$ T+ d% \9 r
return 0;1 f! ~. o! T7 t& s' {% H
}
5 w0 ~0 {3 i9 u2 U& K" O4 H3 \9 D2 C2 P
char get_precede(char s,char c)5 J8 \! P3 b o4 Y+ Z( Q+ l
{
1 `% V! Z! r4 W6 v* D/ n/ j7 n& I switch(s)
/ n: g0 G9 ], ?9 c {) x P: n5 C8 y7 f. I( _
case '+': 0 c5 M O# C. }) D* Y9 \) C! |
case '-':
8 P% [' `4 \; t+ o if(c=='+'||c=='-')9 W0 h- g9 g2 X' I5 R- K9 D
return '>';
0 V! @4 ]* j1 u1 J. i! Y else if(c=='*'||c=='/')
/ c* r6 ]5 |# R. B# C5 t return '<';
7 ?% _7 }0 B; M1 B0 l6 T else if(c=='(')5 |( o, C" X4 D, Q+ p9 r
return '<';/ r0 o3 [* o2 @+ S* n3 @9 M2 B
else if(c==')') e" o: B/ e1 |/ g
return '>';
, e0 i/ y6 w% ^1 x6 | else
1 {: T5 R& ~" a t+ ^" E3 `0 z return '>';: c' s& G- ~3 l9 Y
case '*':. M3 ~# R0 a0 o$ u6 X) R& @" k
case '/':
0 x+ [- `7 t. C. F, @! ? if(c=='+'||c=='-')
q4 Q3 D+ s( \( m8 H return '>';7 N: H. {/ A8 r" f o# f$ u
else if(c=='*'||c=='/')
" g- S7 a* B7 |4 [. l return '>';' g( [% r; T! G- f- b& ?! C9 H' [
else if(c=='(')0 N8 W6 B* M! W5 w4 v- j
return '<';3 k0 j6 r* K6 U; n8 [6 c" `& r
else if(c==')')- j E0 |3 n9 h8 B- k2 @
return '>';
0 `1 K# T; V, ~* m( ?2 P6 ]5 u else
, M0 `8 W& K. U$ D; F3 B+ P return '>';
) C7 T2 p l$ o, I case '(':: ^9 e S- J! v6 v% }6 J5 K! j6 q; l$ D
if(c=='+'||c=='-')
8 y9 r$ `2 |! V9 I }* M( U+ [ return '<';
( W6 w- I3 q% r( H6 a4 L* n) t else if(c=='*'||c=='/')8 p+ `8 y/ ^1 E- K1 `' @7 T1 K
return '<';
: ]% N. ~+ [$ r else if(c=='(')3 s$ i" }( z+ W5 W! e
return '<';2 i/ P. K1 l6 _, d4 W, M
else if(c==')')
% L( q# u1 w, ]3 }) X return '=';. X9 x* t6 S+ {$ Q2 f/ g, c& N" U( @
else
5 M' p% G( q' ] return 'E';) {9 G/ x2 H" [4 m( L( E% c
case ')':/ W+ p7 [+ } \! q8 w4 m
if(c=='+'||c=='-')
% w( U7 [# _* h& }' X return '>';
' V' D4 K$ \' Z: ~/ I! _ else if(c=='*'||c=='/')
7 ~7 M) f2 y: N" A( \% L0 D& V return '>';8 {: p' b( h0 v$ p- R* m
else if(c=='(')4 R- j; J* G, O" s+ L$ u5 o6 f
return 'E';
( d; K+ y) d" N3 d! ?2 ~ else if(c==')'), L& Q! _. |, p" ~
return '>';
- u L- j) G) e2 { else; h0 u/ n6 [" ~! O4 x
return '>';% X5 b9 w7 v, D
case '#':
9 R/ R3 `$ J- W9 e: ^$ v if(c=='+'||c=='-')
' O+ @$ f; g( P* r2 O return '<';
1 l5 {' ~" s) x4 c' o9 q- _6 I else if(c=='*'||c=='/')2 S$ k; ~1 |5 G
return '<';# r5 u3 M6 F9 x# _5 X- A
else if(c=='(')& |2 y7 K, j7 ^& r
return '<';/ y3 u& Z& y: O$ I5 U# W
else if(c==')')8 b1 F) _( _% I/ g) E4 C( Q
return 'E';
3 M# i( N( o( N9 m else3 [3 h& e% i$ R% k W
return '=';$ m0 ?! }+ N4 y$ a) A: Y
default:
8 P2 N( [/ Z- m0 Q+ R break;$ p1 D, ?5 p* ?2 W+ B
}9 A9 M* i9 ]! o5 G
return 0;
1 E: |3 y5 {, |0 X1 x}
7 d- f4 C* S; @1 H3 o2 U v0 q2 b) f" m
int isOpr(char c); ~( W+ |" A' J) D5 @ `1 e
{
3 u& c% H8 v, n1 R. C) a if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
; u& `. B2 [2 x: r) ], ? return 0;4 Z4 P; t9 O; G+ b% W) N; m+ a! b6 _6 t9 [
else $ U/ x( s7 B% s3 O
return 1; P4 v( z5 a" w1 S u) F+ \
}/ G+ P, v: @2 ?. Q/ r; f- {9 c9 m( M# b
I) P, D! J: N8 `4 T% i0 i
float operate(float x, char opr, float y)
: S0 a3 h% E Z1 d$ c m; [{
& O$ T* l( S8 e2 V, w+ Q float result;
& Q* `( r% R3 l) _. g3 _0 \ switch (opr)7 `* f1 v4 m! M, q
{
% X9 [' x8 D- H& ]2 P case '+': 8 X B) Q/ g, M# s$ Q" N% _
result = x + y;
+ l. E+ P- X4 `0 z! [0 S- |- C break;
* h" }0 K! q# E* n d case '-':
( f+ e8 g* g/ t1 f% h- s/ i5 { result = x - y;: z% ~+ y: p. m$ d5 u& g0 ?
break;% o6 B4 J0 Z& Y: e
case '*': , b1 p# r* Y' b2 Q
result = x * y;6 w7 m$ {- J, O$ J. \
break;
2 p& n6 P$ U6 V& N) _8 x/ W- Q case '/': 2 M# b0 V0 ~$ w/ o6 ?( k
if (y == 0). m7 c$ `1 R% V+ t
{2 N# R/ G0 W5 r& r m( m7 T
printf("Divided by zero!\n");- y% W: _" k0 m) a- r8 R
return 0;
& ^1 ]$ D' C }' I5 Y3 p }
6 F$ \! W& S- ]+ P& U else9 N/ [/ M0 w% g5 K1 O* t: Q5 c# t
{
9 Q \" a2 J* M- }/ U. u& o0 o2 M d result = x / y;) c4 s3 {0 r/ s' G% J4 b
break;# ~7 ~2 z$ K5 E; H
}
" d1 g5 L# U6 @' a" X, B default: 1 J# W4 s \3 W& P! ]" J
printf("Bad Input.\n"); # Y" F. R: l. L7 J# a- f
return 0;# T2 j" t% q9 E6 }. d3 f
}$ t: }9 m9 l7 h* r; r
return result;) u) v) {& V' j# z8 L3 V9 i" ^
}
- Z4 P- L+ [/ A! q2 G
0 \8 w V8 U r+ q' C; Qfloat compute() /*计算的时候运算符栈顶结点的优先级始终最低*/' G/ L8 _3 G5 X2 d- y
{/ v, W$ w. J# L
Stack optr,opnd;
+ x! I8 t2 T3 J$ \ struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;" V' } x% O8 f, s
char c;
; M; w. G8 B* p char buf[16];
; u; ^3 N; p' U' N# U int i=0;
+ K7 E0 F$ Z3 H' H9 l$ Z
. e M% {% K' E1 ^& Y* d InitStack(optr); /*用于寄存运算符*/$ q/ p+ R" p) l' m+ K( k! b
InitStack(opnd); /*用于寄存操作数和计算结果*/
$ f2 v; v, w) [1 {$ W0 ] memset(buf,0,sizeof(buf));
2 s, a5 c4 q' P: N
( E! m6 L+ R3 E printf("Enter your expression:");% n) p# |! F: O$ \
2 w9 F- G7 J9 M1 S
opr_in.ch='#';/ t9 t# M4 ?3 @/ @$ ]) x
Push(optr,opr_in); /*'#'入栈*/% b( X+ w5 Q) _
GetTop(optr,opr_top);. T& J" I) j: E: F% D
c=getchar();( M% a2 V" L& J( n- Z9 R
while(c!='='||opr_top.ch!='#')5 c. q8 O! D2 s) ^8 @5 F
{# t4 ^1 {/ E- l$ g' B6 ?; M9 m
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/! R: \- X- A4 x5 ~" j
{( K2 y6 L; f9 O
buf=c;
: Y/ E& \* N' h& u. v+ _, z* h i++;
! X7 q$ [* P, K c=getchar();7 o3 f! p V1 ]& X# d! o, m
}
5 X( H; c- o3 g0 R x7 w* f else /*是运算符*/
( f) c# ?* \$ u+ b9 L {1 [% \4 f3 Y9 Q. w
buf='\0';( j" C, ] g+ _& }0 D1 J
if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/: ?/ y# ` x/ W1 e8 ?
{
W2 {& p6 M7 [2 T# T) l2 d opn_in.data=(float)atof(buf);
; I, _2 w9 |" r8 R, ~0 F Push(opnd,opn_in);
6 `" D$ a; F9 g1 e* B printf("opnd入栈:[%f]\n",opn_in.data);) h4 b/ Z' _ s8 ]& E
i=0;
' Z, x- y+ M5 \2 Z0 G memset(buf,0,sizeof(buf));6 R9 s- D9 N% t! s, u& \
}
- }7 m( h! G h opr_in.ch=c;( w/ @/ I4 [0 w' m
switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/$ @/ Q: l) d3 h8 z: w" {2 R. y
{
" G3 [* F5 w9 n6 K! V2 p$ v% E case '<': /*优先级小于栈顶结点,则运算符入栈*/
: m( x/ D/ r5 Q" B2 U3 ^: ~# H7 C Push(optr,opr_in);. l, X8 W% _! |, o8 b
printf("optr入栈:[%c]\n",opr_in.ch);0 |- v3 ^; P: Q6 E+ R
c=getchar();# j- q1 {+ P# I# }, l' o" f7 I+ R
break;
+ }- j" r2 q! P; N- z4 w6 x7 R case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/* C* P8 z2 @. l K4 \7 M
Pop(optr,e);. W4 i( M! t" V
printf("optr出栈:去掉括号\n");5 k. o/ Z( W- n
c=getchar();. r, O0 G3 E& {$ V% d$ k) ^) ]
break;
# B3 e2 W; s3 C' @ case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/ |* H! i; ]& I6 L* h) x
Pop(optr,opr_t);- }* ~. I2 M& t( }: n. Y; u
printf("optr出栈:[%c]\n",opr_t.ch);
! n: `& t r! D0 u if(Pop(opnd,b)<0)5 S* ~3 {+ Q7 C% d) h6 S( I) D
{
. Y( N) J7 {" s& k1 H8 O printf("Bad Input!\n");: q& w6 P" ^$ u. W5 j
fflush(stdin);5 T9 w" G. q3 W. A1 v- N
return -1;
/ U& p4 ~! P S }
2 \- R# C& d% v% E$ j9 | printf("opnd出栈:[%f]\n",b.data);
* J. y4 f' I) P0 d9 Y, }6 W if(Pop(opnd,a)<0)1 ?# X4 G: M3 o. V" Q& {/ G
{: O' ~) A5 T( m7 O+ j! w3 L
printf("Bad Input!\n");% x7 l* ~- p3 X) U7 W1 B
fflush(stdin);" L( V* ]3 [4 Q. E9 Q6 Y
return -1;
0 I6 G0 C' T: {4 C4 f }" w5 _9 d& _6 E6 y0 ~, S0 K# W
printf("opnd出栈:[%f]\n",a.data);9 {/ j8 N9 l, P7 q5 K3 g3 x
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
# B3 @8 R. u2 r' _5 T A' r Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/1 S: s& f/ y u7 b
printf("结果入栈:[%f]\n",opn_tmp.data);
' ^8 m9 g& ~- A" B3 r break;
3 q( z- C- g/ M+ p% |0 O# d }0 [8 ?7 o' J; n: A
}1 c3 `' S( F3 u) o9 C" H; ^+ c) L) w
GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
% O- ]* q# C3 I* k5 m }
% @ N9 h& k. m, X2 r0 a GetTop(opnd,opn_tmp);
: {& Y! f6 z& t1 N9 c7 n' o DestroyStack(optr);
v5 p1 e$ A: Z. L; q DestroyStack(opnd);
4 a/ Y, N: q2 ?. Y return opn_tmp.data;+ N- m: Z! x0 Z5 I' j
}( T3 s) w. H- ~% B# |$ k2 z) p6 G) @
5 _) l8 S! B$ I0 vchar *killzero(char *res,float result)7 k/ V9 W8 F, `0 V1 `* N, N
{1 G: F$ u* ]) g+ t/ L. `
int i;
* m+ X4 U/ d. D& ]8 w
0 C1 Z, k) h: m2 L sprintf(res,"%f",result);2 ], \! o( m l3 B3 n3 U2 H5 j) }
i=(int)strlen(res)-1;- m1 s$ X- l0 H5 m" s% e, t" g
while(i&&res=='0'); W( ]1 z8 x5 E
{+ W o4 Z/ H+ n) |. _
res='\0';& r/ A3 \" O: w) ]* i
i--;
, ?9 }3 C" w, t* i) N" X X }
v! _; |( c- _3 x9 o if(res=='.')
q# @' E& q# G+ b& {* A9 I) M Q) s( n res='\0';3 Q, z( f) p5 a" t I1 z
return res;
$ L& n! q' k& M" b1 H}+ R |+ ~+ L0 U J& o( @0 G
! [. v; J- B7 `1 Vint main()
9 C' O* }( v- G9 ^; j{
3 H; j- A1 v! S$ D char ch;
+ s. {7 ?( K" H. E char res[64];$ b: c# s0 c) f. R, v/ }! C
float result;; t9 }' L& O# ~; F+ G& }
while(1)
7 S6 ]# V2 {* ` {3 H5 u3 q+ r6 w5 p
result=compute();
! R8 N9 I: X5 c7 N5 G: _ printf("\nThe result is:%s\n",killzero(res,result));( u+ Q' f. z1 u2 q' n
printf("Do you want to continue(y/n)?:") ;& z" _- ?, q* e- Y
ch=getch();
; [3 b8 \% t/ G5 I8 f# o putchar(ch);: \+ ?6 e: ^; N) @
if(ch=='n'||ch=='N')
/ O0 U: A. N, a- f N- ~ break;
4 z9 J3 T1 |9 D% J- q" i, \4 S else5 b+ i& H8 Z9 a$ b4 \1 k) R
system("cls");
# V) g+ ]4 ]. B$ z }/ G$ U9 \1 q8 L6 U1 M
return 0;; C5 V9 }& j( N0 ~& x( ?- q9 H
}7 s3 H/ P# X4 ^& F0 l$ r$ n' ^
- u! ]% S5 T' F( J0 N F% W
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ] |
|