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

|
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.! |1 b" G$ T1 L. D$ M
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
5 j8 _" l8 P) {6 D/**************表达式计算器************/
. {3 p. u7 g: S/ `7 i* f. D" o" X) ^#include <stdio.h>
; n m8 l/ S/ x#include <stdlib.h>4 ~4 ~3 Y3 h" X- y+ _) b/ t0 Q
#include <string.h>9 e( y1 X! T N5 ]( y# R$ R
#include <conio.h>
3 l/ e4 d. k( u# ?#include <malloc.h>
- [' G. w5 m& W5 K/ d5 [1 U0 r2 M0 b8 l4 k; v/ A E. p6 G
#define STACK_SIZE 100
5 k. S6 r- b% ~! K#define APPEND_SIZE 10
$ X& U6 z! `, [( J
; w0 B- Z# T2 }9 A( s9 {struct SNode{
* `! J! n% S* M/ ~( Y3 ~ float data; /*存放操作数或者计算结果*/4 v) A( N! u. ~6 C
char ch; /*存放运算符*/5 j: \( M( ]/ C+ K7 u, H
};% e) j! }% H/ O5 l$ N, n( E, _
# B3 _& E" C0 q4 i7 w9 R4 T. _struct Stack{
) d* g. F. j O6 q SNode *top;
, W$ y$ C! m- z* \# O) i SNode *base;
. y' E* S4 G" u( m* m1 n2 d/ i int size;: r8 d3 t0 G0 C+ F
};
( f" P- l2 j7 ~9 x0 |
" `; H" K+ Z$ [7 a. {5 R/*栈操作函数*/
; b6 s0 N5 n2 ]. U/ ~int InitStack(Stack &S); /*创建栈*/6 I6 }* P* r. g
int DestroyStack(Stack &S); /*销毁栈*/
# C0 {: v. o3 d( qint ClearStack(Stack &S); /*清空栈*/
! q1 }' \' r( G' L3 z* _+ wint GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/# O, W% i+ `4 o9 B" Y
int Push(Stack &S,SNode e); /*将结点e压入栈*/
7 W5 a/ H8 Y* Jint Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/+ M! Z. H5 T' X' d T9 w/ _) X0 h
* o5 S3 E- G& V+ \, l
/*表达式计算器相关函数*/$ I7 B; l+ C# I
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
) w. y( ?- j. j( R5 ?1 Hint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
' p) ?& m Q' K/ D. X. Hfloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/- |$ t) F' N1 y6 q/ q3 d. r
float compute(); /*表达式结算器主函数*/+ `; e D: y/ _8 d, F" i! R! j. x
char *killzero(float result); /*去掉结果后面的0*/ & B @& Y( N$ Q( Z( \0 `
: o2 E; _9 ]: q' b/ L
int InitStack(Stack &S)
; ^- U7 O& ] w$ Q2 e{" Q5 @# l- q8 [
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
8 q9 a9 O; S- Z1 w D- o3 Q4 o if(S.base==NULL)- F& z& |0 ~/ B& |
{; O+ g$ x, D) q
printf("动态分配内存失败!");, p/ T; e. u0 I# F+ @9 Q1 v- A
return -1;
( ~8 `# l5 V5 C% ^" a# _ }% c( {7 g2 U1 f3 C4 }1 }
S.top=S.base;
* I6 ?7 {1 b: p# T% w$ g S.size=STACK_SIZE;
+ i Y6 s- X, [; ^* r! F; y return 0;
9 `- S6 b0 Y* b$ B}( [4 y5 f1 F u* B
" a/ c* O/ D0 S1 k! Z, ]! a1 Y
int DestroyStack(Stack &S)
% Q8 l% e4 f& f- g6 T; Y. v r2 W{5 [" ^9 x7 Y! L
free(S.base);$ b3 `% K) D+ ]/ ?
return 0;3 ~2 U, }# M: I4 ]" T
}
* \! w: S7 E% F g' \" |8 M/ `8 K8 v5 F* U3 Y6 X! b
int ClearStack(Stack &S)
; k$ t$ O( x+ E* B/ n1 i{
5 M1 {2 Y4 [% z$ a. N S.top=S.base;# r0 ~4 k: n- b1 v# C
return 0;
" B) r3 N+ a1 O6 n% `# g! g}! r# B# h: g- ?: _$ ]( b6 F
- R$ K- T' \- o+ |3 D7 B
int GetTop(Stack S,SNode &e)2 J( e* |' a8 d( ~
{
* m# }& x* }1 P) K1 K if(S.top==S.base)
* V1 h w% }" c; \0 t {' q' c+ O( z y$ B5 a% I
printf("栈以为空!");6 V' ^: W# q, j5 i2 v* h6 }
return -1;
7 J. D9 V( d+ H+ }4 w }9 R; u; v: I( G$ L6 V) j0 N/ [) R
e=*(S.top-1);9 D# a) d3 o6 W" N) o& j
return 0;9 b5 \; z9 H' Z" z
}
8 j; k5 |( R" p7 m+ F, o
7 c' u- e* |( ~! ~1 a& T# fint Push(Stack &S,SNode e)
1 ~% k) D8 R6 K{
/ b: U& @( k! K9 T if(S.top-S.base>=S.size)7 k0 }7 K$ K( w
{. P+ y% Q$ ~, E7 Y! S
S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));# A. A2 A" C K; m
if(S.base==NULL)
1 U* Q1 n! U8 b" V& ~- X4 C {0 P, |' H$ ?6 b
printf("动态分配内存失败!");7 X3 H' d, g# v3 a c
return -1;
5 P- D0 O' R' {# L1 \ }! P! I% }( Y9 K- y$ G( `
S.top=S.base+S.size;8 X6 h) Q+ Y; w$ Q% ~3 |8 V8 C# ~
S.size+=APPEND_SIZE;% \% p; {6 v8 r! b1 F5 m% V
}
3 }- m x6 b) e3 Y *S.top=e;; {& N: D9 E% Z2 M3 ~5 e" W9 v$ i
S.top++;
0 l) [4 Z j! M+ U8 _# Z3 E7 S& @ return 0;
. y: G% u; O% r8 w' G; T$ i+ f}
1 g9 t" ~+ B# _6 @7 Q7 R4 t4 {# w; A6 k- o! d: ?0 P0 p
int Pop(Stack &S,SNode &e)
- v2 d% C1 x( p5 b- n4 P: j" [{+ R0 N d E. Q" O* s# k
if(S.top==S.base) {2 k; _/ [% {: H- z
{4 g3 w0 J5 k$ ~6 T% b5 P. d4 @: j o
printf("栈为空!");1 ~9 o+ H( b" ]+ M) l
return -1;
; Y6 z' h, Z2 Z; D* O; _ }
3 r) f! ^! D3 X" u; V e=*(S.top-1);
$ r6 \) d; n. m. S. T k* ^, z S.top--; s Z1 }; n, f& @ T# E( O
return 0;: {) C( t0 q8 Y! d8 o3 l0 ~
}
- j9 f$ ~+ @2 o' P! v. L- G, {- ~) @/ S# j# K. v% V9 K6 s
char get_precede(char s,char c)4 A4 h% q& E$ J
{
- _! D) s: V/ r5 T switch(s)0 o% k' {& L) J1 V8 f% ^
{
5 Z1 p& b: X) B; O case '+': # a1 _' Q* L* K- G
case '-':
/ T/ y) a; Q4 t: s) f if(c=='+'||c=='-')
* E6 f- H- ?! M, }1 z/ C return '>';
& Y! I, E0 S- o# @# A: b else if(c=='*'||c=='/'), | U2 e" C$ E
return '<';
; }+ l- U I' h5 f3 u else if(c=='(')$ P& c$ O+ C0 y9 [9 f
return '<';
9 z" J5 |, M- C6 |' R$ W0 h \ else if(c==')')* t4 G* D: B% c$ w
return '>';
2 K( c! b) C* L+ |; c else
$ a) ?) p1 o+ m6 m return '>';; @" r1 C. i# J" \8 e9 |2 S5 Z
case '*':# A( p0 v5 U* P2 n
case '/':; C/ }$ i! N, p: Q, @
if(c=='+'||c=='-')
% C; e v9 D9 J return '>';5 J3 c, x) z2 m) F$ v
else if(c=='*'||c=='/')
' T0 O2 b, U" D. P/ Z0 i4 u return '>';- t. i: n' B8 D9 p3 J
else if(c=='(')3 Y0 B0 F7 z, O$ i$ `# x
return '<';
; |# v! D7 D$ e/ V else if(c==')')
g1 D k7 I6 X( E7 k return '>';0 |/ ^7 {9 f% q$ l1 l5 k0 H
else0 H! ]+ W: g, Z6 w7 {' S! ?8 j
return '>';
& t5 i7 Y" R# M0 H( E$ B1 x case '(':
( E/ X$ }# H1 w$ s: R% i, _ if(c=='+'||c=='-')
! ~0 N; M' N8 l4 d return '<';
" U0 v! { V/ b8 j7 N5 D else if(c=='*'||c=='/')
?) _4 q5 m' W* ~% l6 A return '<';
8 E6 O& ~+ C" F) Z5 d else if(c=='(')
" r; r* m! R+ A [ return '<';- Z# F' [9 L4 `" k. K
else if(c==')')' @- v( A4 s0 m4 f& }6 Z
return '='; Z4 g) P+ X$ |# G! [& o
else- }9 D% _7 n9 `) D/ i' g7 Q
return 'E';8 n# Y1 J: F( O" `
case ')':8 u; S( D2 y' c/ A( J
if(c=='+'||c=='-')
) U- N( v& H$ r. e( X+ @ return '>';" H# T2 R( f. G, h% V; r! E
else if(c=='*'||c=='/')3 @- l1 E6 e) r9 p6 B! ~8 y( ^- R. h
return '>';
0 }( D8 e; U3 X" }: c: T else if(c=='(')
3 M# z" i- I6 @, q return 'E';, G+ `2 d$ H& w* M2 k: E& v4 O
else if(c==')')
2 m- D* G6 }* }' |+ Y! z return '>';
; ` S3 Y& ?! {& j, p1 F else! ?) o3 H$ p* B: o( h/ x
return '>';
+ o- B: P2 _7 T" k" ]5 ^ case '#':
5 u2 v3 `2 c3 ]0 n if(c=='+'||c=='-')
- i+ v# o$ B. H. E! T7 F9 d return '<';
# I* S9 h1 S4 G# M else if(c=='*'||c=='/')
: _- n/ n* V ^( e return '<';. i7 a0 l. q7 P* l8 K
else if(c=='(')5 ]1 E: Z2 h8 I# T. ^/ L1 {
return '<';; s2 |1 W1 l# z
else if(c==')')
+ j. I' W1 d5 u; z) o2 W return 'E';% T9 i7 D% I( k1 K2 x0 `) E
else7 R( a0 l0 ^" Z
return '=';
5 w0 E% U% _+ x! a$ b. {4 P default:
4 `* `+ q" I, l0 E% ^6 ~ break;) e; h6 L2 b% ^( M. @6 b
}
p# ~% u% k% k# z3 g- y H8 Z return 0;
" Y6 B6 `( i( T0 w' e8 @/ s4 x% m}5 L! y( S* }% d1 G
" j$ Q4 _; i- T# ]6 X$ T7 W
int isOpr(char c)) `- b4 q3 F1 j ^
{
8 ~: B8 t5 g& }* t/ u5 ?( Z if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')3 B8 G8 ^+ i, j+ n+ u8 Q
return 0;
9 E/ S8 ^+ Y, m* j# H# W* D. S% | else
* g$ K, |( m& I1 y) T return 1;
3 a5 O* ^- D# f( o7 b6 O}
" g2 V4 y/ C- H- R, j6 R* H$ M" K1 i6 [6 n9 n: o) ]
float operate(float x, char opr, float y)
; B/ t, A9 L6 g. j: F$ q/ w{
5 a' m8 w7 k3 u' h float result;8 W# c5 F" A( h, Y/ h7 q
switch (opr)
, b: O0 T" r$ k }7 q {
, k! l" y) P( V% L/ e: |5 T) |+ u case '+':
; o1 M/ d! R3 j6 A& V! ?6 ? result = x + y;
; u/ `! k% \3 U0 U0 ]% N2 Z8 M break;* V9 ~5 r+ |$ G# v$ p1 R
case '-': 7 a5 h2 Z" O, N- E5 ^
result = x - y;
( Z# G7 G3 I8 ]* D1 @# T" N- p: N a5 W/ b break;
, q8 N0 W \+ Y( h2 `8 @: X3 t case '*':
( f: o; e: N: M, c1 k/ s& m3 s) Q result = x * y;) g( i1 ^% O5 d* f* J# R
break;0 I& J5 j7 ?* ~. h+ m" K7 W- |
case '/': * S# _6 T! y* H( H7 o) @
if (y == 0)% a" ^! ?( U) }8 A: G* s
{
6 C( E6 s( Y% A$ @# @- h2 v printf("Divided by zero!\n");
, B. p2 v! z# _: A4 M7 T' Y return 0;
) p* B8 n4 A" Z& S+ P G0 Q/ B }
- {2 }( Y% J# l) Z2 Y else
2 r/ C7 T. w* g/ V! B+ r {
& b' J: Z2 `! l, M; A result = x / y;
2 h5 x5 L0 u, T- h7 A break;
- f3 T- o3 q3 x0 s }
) M1 Y' E1 _1 E default:
2 N( S' J. H4 w5 [2 M8 t printf("Bad Input.\n");
4 V' o# C2 z' I: V! v return 0;
" e0 `5 O* c' u* T1 ^) D }
/ g( q4 H; F4 I; }& n return result;
' }& c& t, [3 |" P# M, X. L} & h# e& B( t; {/ ]6 I
M L! m# P9 D. Y+ Ffloat compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
4 N8 P$ m g9 a+ n% H' C0 c{. ~6 C, M) v, ]3 q/ D
Stack optr,opnd;4 V- j7 p% G8 O' b
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
6 P5 I! K2 L0 V* s char c;1 `( @ d" n+ W2 s3 H& d6 r
char buf[16];! G. J- B, d3 b$ A- `1 I
int i=0;
9 J6 l! U# c" x 8 }+ n5 @8 n1 X a9 h* C
InitStack(optr); /*用于寄存运算符*/
. G2 y% V8 L/ e0 l+ p8 P9 J7 k InitStack(opnd); /*用于寄存操作数和计算结果*/7 U6 H/ i4 p/ k& W$ }+ _
memset(buf,0,sizeof(buf));( Q* f% \1 s3 P' `) T9 I# e) k
5 ~8 A. E/ Q' ` printf("Enter your expression:");
# P/ Z& L7 T3 i3 ]9 _
, u* |2 \+ {' d: q) t+ Y/ L opr_in.ch='#';
( Z* C( |5 P3 j! ~/ x( h$ C8 p Push(optr,opr_in); /*'#'入栈*/1 R1 B3 m# G% ^8 K% P" P
GetTop(optr,opr_top);% I; w: g/ h; r2 ~2 {
c=getchar();1 a1 V' ]% E: u; z$ Q% z
while(c!='='||opr_top.ch!='#')
# |7 I. g$ V1 W4 k6 H1 O {' X$ N$ f6 y( a
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
0 T% W x% I2 J+ V2 O0 F {0 J: y* |6 N/ ~1 D; b! o# l
buf=c;
; K5 d5 e; f- D8 E% @7 `/ y8 T i++;% {9 e9 C% r% @( C: t* y
c=getchar();
# K. T. d+ c* v }" z9 y0 \4 p& G, t3 {
else /*是运算符*/
: O1 W& \& |0 ]. i2 f | {
3 N; C' @: a- [3 j/ W0 Q$ h buf='\0';1 {' X8 L/ N$ j0 A; W- k
if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
& G. ~8 M+ e% @# Z {$ z% W* g$ c' f( X6 c& a2 b
opn_in.data=(float)atof(buf);
1 L4 k. ~8 v) [; `; S- m Push(opnd,opn_in);, e4 a7 w( M5 I) B x
printf("opnd入栈:[%f]\n",opn_in.data);4 G" o% ^! ?8 V8 s- |' X* O
i=0;
7 _& V8 b/ x& w L memset(buf,0,sizeof(buf));
2 H7 V ? p' C. b; C }/ d; v: o- ~+ o0 L" t& H# k
opr_in.ch=c;. }. h2 O4 F. O K2 Y- Q
switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/8 ~' n& y) K! t4 \0 Y9 s) h
{( {& y* h; M# A1 o9 ?. A
case '<': /*优先级小于栈顶结点,则运算符入栈*/- }! x+ P% Y$ e6 b; t! V
Push(optr,opr_in);; c5 U: ]; L4 p: \( l
printf("optr入栈:[%c]\n",opr_in.ch);& ?; |, d4 n& c, n2 r" k
c=getchar();* |+ f) d+ Y. w4 ? T% p+ k
break;: z: d" {, I% a- g+ K2 @
case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
; t8 l& n6 B, v/ L2 Z+ q/ H Pop(optr,e);" E0 ]; `' {! t1 Y! [! J
printf("optr出栈:去掉括号\n");4 @/ K" e, d+ N7 q9 ~( y4 k
c=getchar();+ @5 f; Q: w- M" M' F8 p
break;$ e# Z4 C( t! a
case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/0 e$ T4 q" C: ~5 H q5 k
Pop(optr,opr_t);
' |7 B" D7 p! c6 x+ F printf("optr出栈:[%c]\n",opr_t.ch);
! _5 k- k; M1 l1 Z if(Pop(opnd,b)<0)
: }( S8 Z6 W1 l. W {
9 \$ I4 {. R8 E( S printf("Bad Input!\n");
* p; H( W% O) p0 [ fflush(stdin);# D, {7 N/ a) u/ e2 R8 x% f
return -1;8 ^; R. _0 u. E5 V9 j1 N: f
}' E% Q% n( I V. o
printf("opnd出栈:[%f]\n",b.data);
; V* l: `: G( a* Q5 R+ n if(Pop(opnd,a)<0): A; X2 O0 y; O7 t" |
{
' Z: X7 B. L4 }$ C5 j! L printf("Bad Input!\n");
: }. {' ^) c7 V. y1 \6 h9 a fflush(stdin);
2 k) y' Q2 `% ` return -1;
$ I8 M- y3 r, n2 O" I; S" H4 j }% a; m; M0 ]1 ?) {# f
printf("opnd出栈:[%f]\n",a.data);- W0 D$ v! v/ i3 c5 V8 c
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
' u0 T. J' Y) e7 ?) l3 D* ^ Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
7 @. k. S3 k' O/ ~& s( o6 Q1 v printf("结果入栈:[%f]\n",opn_tmp.data);( `, C# A0 h3 U% r8 o
break;
- S# w8 ^1 W* E/ k } z4 j4 |2 | [
}
4 S7 H; C) e. d, N$ ?( X. B8 B GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
- L2 s9 r0 N/ H2 N7 a }3 U) W* v+ A) Q/ R6 M# V
GetTop(opnd,opn_tmp);
9 v6 H$ x: h/ V+ C: j2 v# u0 c6 ~ DestroyStack(optr);
) L/ y# k) K+ @$ Y4 h( V3 p; h8 q DestroyStack(opnd);
) e5 E: ? ?; \6 ? return opn_tmp.data;
8 r0 b }* K; Q3 T0 P/ v}; a& f! M/ m/ n0 f5 V: S2 b: b
3 P6 J2 ]; \6 U$ n5 P+ z
char *killzero(char *res,float result)
& T( D/ x) v, Z{
' M8 L4 U: U @+ B; Y I int i;
6 |- b- f* N& t: \' W3 B: y
/ j! I, X. T5 D& w sprintf(res,"%f",result);
* h b1 W" ~( x1 X, l: T i=(int)strlen(res)-1;' m& `7 o& ^4 L" W6 R4 u, _
while(i&&res=='0')# J6 ^8 l3 m( r0 u- B( t: Z8 o y% B! C+ P
{, `3 n$ ~7 v, A, }/ K" s
res='\0';
4 W9 q7 w6 Z) \4 e3 l6 M i--;
& `/ G$ a% ^8 u& U. G; ^% S }, e4 p, r0 r; S2 e; b" I% k
if(res=='.')
6 R" M7 ^( [3 _ O- T- [- k2 x res='\0';! U5 ~0 H; m% W
return res;
) c! |& o2 q( A7 V0 M}
3 w' Q" D0 [! ^( g& l) b8 Q0 ^ B4 L: H& d5 b c
int main()+ @1 F* ]+ i' o2 m
{
$ X5 s# G( q7 D: T4 U6 w# C, O char ch;2 Q4 }& Y. B: \) f1 X) G- t3 t3 K
char res[64];
1 g% A' N. f: H" U6 q: W float result;
R: B/ S( T$ t* i/ \7 d6 p8 o while(1)
9 \$ g$ c% s6 A. a {
8 F0 e. x% G/ L8 o! a* v# G result=compute();/ P; L6 n9 T# D/ F
printf("\nThe result is:%s\n",killzero(res,result));
) n. y4 m) l1 V printf("Do you want to continue(y/n)?:") ;
- b% F8 |0 T8 m" b8 C9 e* q9 ` ch=getch();
# k; @ H+ T4 ^0 ^' F putchar(ch);4 V7 m7 F" m% ?( U9 `
if(ch=='n'||ch=='N')+ `7 Z: l1 k1 i! ?( J0 q0 l+ `
break;+ C0 q3 P9 ^. {9 E
else
5 |- Q. Y& V: ^! Q" t system("cls");: |9 I: N- E. z$ Z; M
}7 O# A+ z8 u- U. l! x# r
return 0;
* a# k9 K4 y- \( ]. Z( f+ P# \0 @}
& e* A T# w& ^7 ?2 ?2 U) T/ Q$ A% f
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ] |
|