标题:
C语言表达式计算器
[打印本页]
作者:
zw2004
时间:
2008-1-21 17:17
标题:
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
% @# d- N9 F! a1 b" q# K
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
9 n/ h% b j0 G" u# H
/**************表达式计算器************/
: X3 o+ L' K3 }! w
#include <stdio.h>
+ d0 V0 j. W7 ~* _
#include <stdlib.h>
2 P$ n8 U: h& [0 F( Z0 \8 w
#include <string.h>
: r% W r7 b6 M. L' K Y
#include <conio.h>
/ O8 y5 H0 ~" ] H" {# e9 R7 w
#include <malloc.h>
+ [; A6 u$ h, Q# X8 u
; @ E/ ^. X: a, y8 M4 N2 B
#define STACK_SIZE 100
/ G% H2 S+ A0 y1 {4 r8 y9 I9 Y
#define APPEND_SIZE 10
/ J9 ^ i& z; y, U7 @6 u4 S
/ ^; L" B$ S U6 u7 R& C8 u8 L
struct SNode{
( E2 ~9 M1 y7 I+ ^$ u% m
float data; /*存放操作数或者计算结果*/
" |3 q8 Q9 c: V" O
char ch; /*存放运算符*/
' d7 m( N' i0 H H5 x G9 p! K
};
8 B$ @( H0 T- |5 @1 s
/ O7 b" l! t o3 A2 M B1 H
struct Stack{
7 r2 R( F9 E' @3 \; a) ]
SNode *top;
. M+ x9 V* B* j- {
SNode *base;
4 l8 _0 f3 d6 I' R# d
int size;
& }9 [5 v% I5 b5 f; q4 N
};
- _( @' A6 E: I' t% L; N
5 V' u4 g% K* s: x" T5 U* P) b4 D
/*栈操作函数*/
/ c' T9 x! L2 D/ A
int InitStack(Stack &S); /*创建栈*/
/ l. Z4 X8 s7 q0 h4 K! h
int DestroyStack(Stack &S); /*销毁栈*/
, ~2 y1 Q+ D' {$ r
int ClearStack(Stack &S); /*清空栈*/
' H6 h' k8 Z& b3 F P* s
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
! I% y, Y! E9 y5 K0 ~
int Push(Stack &S,SNode e); /*将结点e压入栈*/
4 B; j+ F: f: ?, r5 v6 K$ A/ p+ S$ Q
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
* L" V/ h+ ~+ `. t4 N5 F4 b
( D3 D$ H; a9 @% A% w& N
/*表达式计算器相关函数*/
! R6 U' v1 f0 f4 e4 O$ q; S
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
9 d2 A7 K9 s5 g# J' C
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
+ M0 s, I4 l' i5 D
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
) n c" m* u! @( V, }
float compute(); /*表达式结算器主函数*/
& H' t) I) O7 M! y+ X! N
char *killzero(float result); /*去掉结果后面的0*/
2 y: X! F" n8 G7 c1 c
9 X8 T8 [( N3 @2 R
int InitStack(Stack &S)
% b# ^/ r: p; @
{
1 j: N* r5 J* l8 j P. q$ _
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
6 u2 J2 ?, E$ n6 T o* x
if(S.base==NULL)
: a0 ^8 X7 U" P- g
{
. {' Z! K- B4 E2 y7 _! a! V# w* V* I
printf("动态分配内存失败!");
# r& x8 R) ^5 n4 `1 R6 @! g% s( G1 D
return -1;
6 C4 W2 c. F$ s$ Q: I4 L2 z' S
}
~# w+ r! ^7 f1 Y% e' |5 A7 t
S.top=S.base;
+ S+ n0 d2 y9 M9 }: C( u1 D
S.size=STACK_SIZE;
0 `- T$ y+ r: L' o+ A- J% x4 k6 U
return 0;
, t& Q- J' Q0 I+ v. l8 H! g, p
}
8 Q; L0 r: c2 w7 E7 c
* [0 M) y$ r0 K$ J
int DestroyStack(Stack &S)
8 A* P* |0 w: C0 D
{
9 {& Q4 w$ t5 v- q+ |* {8 G8 J
free(S.base);
/ e! O- w$ F( a% Q$ s
return 0;
2 d7 F1 p) d6 d0 C) `6 z5 j
}
) F% p+ l0 l, `5 z
! ?/ c7 Z3 K* x0 J( X
int ClearStack(Stack &S)
) J8 K, X4 Z# r% y
{
2 ^: ^! z! _0 v+ n4 K0 c% @
S.top=S.base;
# h7 W9 P# Z: k$ F& j
return 0;
( p) [3 T$ v$ ?
}
, @) Q$ \: H; k2 z* ^! g& f
) S2 Z, E* C2 v9 m: C2 E) v# s
int GetTop(Stack S,SNode &e)
5 W" K) \, u# L% I) U
{
% [# _6 `! O. h5 E6 Q% f
if(S.top==S.base)
8 i+ U" T. g- i4 G8 ^' g) Z3 i
{
2 B! F6 H: {0 L/ k" ?$ ~
printf("栈以为空!");
+ W# |* m {2 t" l8 v& }
return -1;
# ` E, Y6 R) x6 z0 U
}
% O6 w: t. w3 B/ D
e=*(S.top-1);
^7 U' c" K: X' ?( ~
return 0;
. C% r6 t* ~% M- j- E
}
1 r' Z0 p' ], C: X: o7 c
q1 s; g1 F; ^- X) u. S: t; f& g
int Push(Stack &S,SNode e)
7 g8 f8 |5 T! y; G W y+ |
{
1 i) H. J+ M' P- Z H% D% h
if(S.top-S.base>=S.size)
% q9 m" ^! ~- ~( Z
{
: E" h A; ~, ^
S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
3 C, }8 X) h. ]( _
if(S.base==NULL)
/ o6 q6 A. R3 W; N/ F! R% [9 {
{
% ^+ _2 O" \# O. k8 a
printf("动态分配内存失败!");
- \( W2 d/ v+ `. T- z
return -1;
% G) ^& o! c4 O8 E* B/ ^, V
}
0 O" J: s+ {$ S0 @- }, S
S.top=S.base+S.size;
# W( H% u! i, E" E3 T$ _! ]
S.size+=APPEND_SIZE;
j' ?0 K% D) }: X7 Y
}
" @: g, m! z% f
*S.top=e;
! g% Z8 a) E" V1 H+ D
S.top++;
! ~' J; y& z/ Q8 b
return 0;
2 }7 S1 F" y8 z ]6 b* f: k8 n
}
: @& a2 |2 o% A9 X9 D
. u) J6 N0 e! c; d5 A* }
int Pop(Stack &S,SNode &e)
+ G8 L7 M/ I( A, A6 w* l
{
" ~2 |7 U6 }; P' R5 n; M
if(S.top==S.base)
, M) R# q) R: j( \" o- s& c
{
0 Q, j- N7 o' o
printf("栈为空!");
. I8 j( `5 Y& y0 t! T
return -1;
) ^; e& ~, L0 X
}
2 F2 R. P* o( x- W. K$ k
e=*(S.top-1);
; D" H& W9 O% H# F' E6 q; `
S.top--;
3 \6 `) |4 Z/ m) v) k4 J
return 0;
* p6 S+ t% }. Q% U2 y* E
}
3 `' Q6 S: `: |2 z, M$ G% {/ J
' N1 R- s g. }$ |5 U1 P) U# T
char get_precede(char s,char c)
6 S4 C' j8 M* g( m
{
0 L! x6 Z/ ]8 s7 G9 f- m
switch(s)
; [. ]4 I, u# x! f3 |! ]: g. y$ ^
{
2 z9 ~% N2 |6 y5 d$ P; ~
case '+':
* E( z& U* H7 ?9 b& Z
case '-':
5 h2 D8 e: ~/ F B. Z- Q2 f- | R
if(c=='+'||c=='-')
7 n* Q( }. v1 i# t8 N% Z
return '>';
& ?& Z6 m8 T: C6 X1 I
else if(c=='*'||c=='/')
/ x9 k& ?7 Z+ c! \# r- a
return '<';
$ k" A' V5 m h" u
else if(c=='(')
4 Z( S/ g1 D5 ~" ]
return '<';
/ P3 L; T2 Y) b' s& o5 Q
else if(c==')')
, H; V4 K* X- z5 h; D/ P2 m. [) R
return '>';
" l C1 |) ?# R& W
else
1 I, K$ L- c& J2 M
return '>';
( k, w" p" \2 A/ C# ~7 L5 ^
case '*':
- ?, H5 @/ i/ S% b, d
case '/':
% M0 Z( g4 k- L A5 ^1 J" x
if(c=='+'||c=='-')
/ y, b2 v7 P" b
return '>';
" ~; g2 H. V$ E! g- R5 Q
else if(c=='*'||c=='/')
# Y$ `; ]+ M9 ]; r9 e
return '>';
7 I7 l: v7 ]; E+ r8 t5 m) c
else if(c=='(')
! ]; b: Q* N7 H% p, W# E9 A
return '<';
9 m: a; t; N4 p) s, q! W+ @
else if(c==')')
3 `$ A) G6 a) C: Z4 b: w2 s; h
return '>';
/ T- u' a* ]3 T( b) T, L* S
else
' k4 r' g& t9 V5 j$ b3 K
return '>';
2 r+ }6 j! O ~: w( s) q1 \
case '(':
3 Z4 i5 j; l; a
if(c=='+'||c=='-')
* ~7 W( G$ I9 V& \2 w/ a Q f
return '<';
4 ?+ c. t9 a( ?% X
else if(c=='*'||c=='/')
3 n) u, @. g% U- V8 W8 c. l! ~
return '<';
# e3 s, ]/ C1 U$ s" P& }
else if(c=='(')
9 O2 @5 E1 z! ?. K' m, S8 s. P
return '<';
+ l% [4 o- O$ y$ d5 c) z2 b
else if(c==')')
* O. g6 u, D0 V( B7 |; w
return '=';
! \1 G4 m( @* O$ Q4 F( O
else
7 W2 `9 B+ E0 E& I2 m' e
return 'E';
+ v: |0 f8 o( N7 I6 K
case ')':
2 b7 M+ x- q2 e# G- J' z
if(c=='+'||c=='-')
F$ ^# X# _: Y0 K
return '>';
# W) V% Z1 |( r
else if(c=='*'||c=='/')
! M6 ?: A4 `% i
return '>';
6 [4 n3 P! m9 r4 F3 n) G h3 F
else if(c=='(')
- I( ]" N. t+ c/ }/ R/ U. d) l3 G
return 'E';
) ]$ Y6 K2 j3 p3 A8 O
else if(c==')')
' J% K2 C- c3 J4 B' G
return '>';
* L' A7 V; N7 O2 b0 J
else
/ G1 t' b$ \ ]4 E) C
return '>';
5 g5 e$ g5 R6 i- K6 s( P
case '#':
. G. g2 f; K: W) b
if(c=='+'||c=='-')
1 W- D9 Z9 f) D( n x: c6 _
return '<';
/ C& J- k! w; ~6 Y+ ~7 E
else if(c=='*'||c=='/')
- t6 ` `; X8 k! @: B, P
return '<';
% Z( J8 I6 J$ Q( U E; ~5 n
else if(c=='(')
) w+ G+ L! W0 X- v% j
return '<';
9 \% L; R' i) A7 N6 j
else if(c==')')
; K' W: K9 u0 N- G. D" b% n
return 'E';
4 |, Z" Z2 q; I
else
6 ~! h& s, C) k1 C, Y5 e4 P
return '=';
/ ~0 G# ^( J8 c0 m, b6 b9 c$ S
default:
0 f5 T4 O& w7 x, C5 ~
break;
7 y8 t* ?3 g& N# `& `6 \ D
}
# K, v5 c" N7 d% W
return 0;
! f1 u. _, F* Z& }0 [! B# V1 P
}
# X- l& N9 j* u- R1 R- E' ? o
. ^$ q7 V: N3 q
int isOpr(char c)
( ~* y9 O$ U9 F {( h
{
7 d+ g$ `9 D( s& E) P6 }1 a7 T
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
& t% O4 \5 p$ e; r( ?
return 0;
0 [( \& S7 C4 k( r. w* x4 ?3 \
else
( |' g7 k, K2 G: y
return 1;
9 n0 E) H6 b5 V- @: T
}
' C2 |; F2 S I4 k" t7 H6 f- R) g
* M% u3 M6 M; ~: O( G
float operate(float x, char opr, float y)
. b9 w6 L, [: {7 F0 w
{
0 _9 L2 [) Q. G8 D% I
float result;
: a4 v% m1 T s7 a; W& G3 l" B; f5 ?
switch (opr)
+ M1 X& g+ i J. G
{
3 G R; D; y+ K7 W" R
case '+':
; X4 Z u5 m. X- ~4 \$ `
result = x + y;
3 A( i" B' B8 c; F0 i( c& E
break;
6 `4 n' j- [& J; |( B( c
case '-':
) ^/ w* ?/ t' p5 m e
result = x - y;
( ]: B8 V: f0 X; r) [, Y
break;
& T9 R2 X; w4 j
case '*':
4 @2 g+ r- Z# n- V' C
result = x * y;
- X \/ c/ V9 r* c2 {- w. J
break;
8 I% n2 G; t' W, R: ]
case '/':
: k& w% Q. A6 Z9 c+ |0 M" O
if (y == 0)
8 z2 `% u' C* y+ E* B' x1 k
{
( W9 Y- S/ M& F
printf("Divided by zero!\n");
% R7 g# ~0 \& h
return 0;
3 d2 {# G% d7 o1 e2 l/ _$ f
}
7 G7 \. C; z! L$ K3 o: `' s
else
k: t# ?3 N2 n7 Z8 a q; E
{
0 t# i" a/ E1 f; i
result = x / y;
7 }% g1 y& k, I
break;
$ _* Y) X5 b& W- m' v9 R/ |. _
}
$ S* d9 X: ^! g2 j
default:
" X* I {4 d9 N) H y" z9 r
printf("Bad Input.\n");
3 h2 R$ a3 [7 W1 j# U
return 0;
0 y" o2 [5 g0 m$ Y
}
3 y- b, M- B: c2 _+ D
return result;
3 @) n# g) T) h7 Y- w2 B
}
9 S& u' Y4 V6 J% \( [
% P7 w8 |4 q+ g4 I& d/ Z
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
, ]. n# b1 o l: `. K
{
& O5 F' w ~' b# A! \5 a* p5 o8 e- c
Stack optr,opnd;
, D9 c1 Q" s! L- {; R, i
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
- A! i1 b4 W0 N& V
char c;
, }, R- J2 I* S, X3 n7 ~9 ]/ ~: R) e
char buf[16];
2 R1 w! T& u# X4 O% W2 L
int i=0;
! P# R" P. R! a
* I" h: b9 U8 _) q& ^! S# M
InitStack(optr); /*用于寄存运算符*/
% U" d; D" X& z* ^
InitStack(opnd); /*用于寄存操作数和计算结果*/
$ q6 v. ~; J3 J4 F1 D% J: R* m H
memset(buf,0,sizeof(buf));
7 F+ z# I& @! m
+ ^" {5 q. ]# q$ |6 \* q
printf("Enter your expression:");
# z% e3 n2 K: I2 b6 N! X
7 G8 T3 ?: v' [3 i2 f! R6 q- _
opr_in.ch='#';
& l- F$ _8 B2 R/ a& _8 r/ Y1 M) V! J G
Push(optr,opr_in); /*'#'入栈*/
+ O" i/ N5 L" n! w U
GetTop(optr,opr_top);
3 O k r" V2 _: l" A3 Y
c=getchar();
2 f; E$ [5 x( M9 J3 y# M
while(c!='='||opr_top.ch!='#')
( |0 L+ t: @5 `
{
/ p4 x, ]1 O- t4 Q `
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
) G# i' O$ P9 a
{
3 M4 A! a- p) h5 g- w4 D
buf
=c;
$ o& s' _: e0 n' m9 d7 k
i++;
6 `& O& f4 @: i& Z8 u
c=getchar();
1 n* u3 _$ r% }5 `) _2 y
}
- P P' w6 Y- u. |2 G- j
else /*是运算符*/
- M0 m: X/ l' b0 o
{
# @: O6 I" K# M3 X/ h% E
buf
='\0';
, l/ L8 v: \1 {7 t! w# r
if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
% A0 u1 G! x( t" ]3 b7 U
{
# a1 |# p5 m# ^ }+ X
opn_in.data=(float)atof(buf);
3 Q- g. `1 ~- S; A" r
Push(opnd,opn_in);
6 B% }- P" W; G6 @. z" e% s7 `7 I
printf("opnd入栈:[%f]\n",opn_in.data);
- |( f( s$ N- P5 W P3 K# P
i=0;
1 j c# C0 c, D
memset(buf,0,sizeof(buf));
0 d& x; G7 a5 U) f K+ m' p* H
}
+ O9 u/ d7 U/ r1 c& X5 q6 w3 V4 X
opr_in.ch=c;
9 v! R1 {7 S9 J; s; x1 k
switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
0 K4 |) b$ y, d$ u
{
) m: R7 Y6 A: Q( a
case '<': /*优先级小于栈顶结点,则运算符入栈*/
9 E7 B) g! M/ J0 I$ K+ V
Push(optr,opr_in);
4 m7 _/ g; W! ^" t e
printf("optr入栈:[%c]\n",opr_in.ch);
2 B7 J" x/ r0 I" A0 m; y
c=getchar();
7 u! a& d9 c$ a: E
break;
; h' n0 x7 |$ @/ p6 R6 T( \- o
case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
. o. H$ X. L5 O2 B5 f0 Z u5 U
Pop(optr,e);
$ e. g8 m# ? i' S4 I
printf("optr出栈:去掉括号\n");
+ O+ ?# }+ V& S. g5 P
c=getchar();
, l- E, n N2 Q$ K
break;
) u2 h" g* Z9 _1 F+ x, B- s5 r' v
case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
' k$ f( m$ K0 a; m8 K M ~
Pop(optr,opr_t);
9 j" y* ^) ]8 E/ c
printf("optr出栈:[%c]\n",opr_t.ch);
' b1 @/ h8 k' H5 n
if(Pop(opnd,b)<0)
) Q& {7 d/ T- G, z+ W# Q6 v
{
* Z- B7 N0 @* c N6 j. p
printf("Bad Input!\n");
{. _" ]1 t+ {3 l' I5 l
fflush(stdin);
8 _5 P# j) L- i D6 M) k* j5 e; Y* S
return -1;
% {1 e6 }, f: k
}
4 i0 G0 y, z" Q6 b8 \
printf("opnd出栈:[%f]\n",b.data);
; t% b* M, X. r' i5 c6 H/ }
if(Pop(opnd,a)<0)
% f! S4 L5 m* E" `
{
) E6 v u3 v5 S' S3 a
printf("Bad Input!\n");
- v ~2 A# M$ u7 J
fflush(stdin);
$ Y4 j; n; L+ l4 E* [
return -1;
5 F& h6 L7 ~* A" _9 X# p x
}
/ k% I j# j2 v5 v# L1 |% z
printf("opnd出栈:[%f]\n",a.data);
% S: a6 B& c& K& A/ ?3 I
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
, B o% r% {) G5 F4 p
Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
0 R4 u. m; S$ w
printf("结果入栈:[%f]\n",opn_tmp.data);
- \* O0 ~) x' s0 _( ^
break;
: [3 m+ X9 v; {% {) w
}
+ m- f. C% C8 [
}
# p# C7 L" l/ m" V# n! g
GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
' v# h U/ n+ \8 d9 ~2 q
}
$ |, V7 N! s8 f; t3 f( q% Z
GetTop(opnd,opn_tmp);
% c1 p; w( I" F& M
DestroyStack(optr);
% e2 m6 I1 R8 A5 p; A
DestroyStack(opnd);
8 K. S$ v2 o8 N4 M" y( x6 n9 E
return opn_tmp.data;
: W* n! T! V5 s0 A) n
}
" h/ @5 z* t- E5 n8 ^% v1 |
2 N; w, b- M' X4 t% q
char *killzero(char *res,float result)
! S+ q9 y, g& s' f
{
4 P$ X3 Y' p* g, v3 N6 T3 @
int i;
; `1 K5 n$ Z9 J/ Y
- u# c7 j( e# a5 Q
sprintf(res,"%f",result);
: F/ \- R' {4 d) d) H
i=(int)strlen(res)-1;
( d$ J4 b2 N' S/ d% C: h
while(i&&res
=='0')
% m5 y8 G+ A: l( \/ M
{
! m7 _5 j6 F1 A% ~
res
='\0';
* v9 L+ \ S" M
i--;
8 @/ v: s$ K! l( I
}
2 o B- G0 S0 x# r5 w. j$ w, V
if(res
=='.')
# j! q* ^( r W3 b5 }
res
='\0';
# s2 X$ E) o2 Z0 _1 S
return res;
0 K2 {; `( z, i+ B0 _+ V- c, {' r
}
6 T2 r7 a, N& e+ w" C# X/ a3 b
, _, y q/ S5 `) K, x
int main()
) x2 [9 X1 S* g: z1 y- W% ^6 E) }
{
- A4 r; r- C, c: Y h) {8 i0 x2 |
char ch;
5 o8 \# E. x6 Q7 c* \! I
char res[64];
7 `/ P3 {" _' p2 Z" v
float result;
: g2 [" m( s+ K% Y, |" N
while(1)
1 r/ Q* o) N, k* S7 u3 W
{
/ U- X! r: E. i( E6 ~
result=compute();
- q! Z! W" Y9 p! n
printf("\nThe result is:%s\n",killzero(res,result));
6 d( e) p% @# T( y0 d7 Q
printf("Do you want to continue(y/n)?:") ;
1 |9 [5 V3 {6 [% u: }# s/ H& s
ch=getch();
$ K* k0 B; ?0 C( v7 b6 j
putchar(ch);
. h; t3 w6 L9 J( d* P2 _% {+ x
if(ch=='n'||ch=='N')
' g1 x& n5 |' G8 e* R9 Y, x
break;
3 m7 }( N% t: Q h6 T* A
else
; t5 t% b: Q6 M7 H) ^
system("cls");
" t4 b! K0 c' G! q' o
}
d0 E/ z0 ^0 G4 A/ _, R& o
return 0;
1 Q6 m! N1 c4 F/ S U# R& {
}
" }$ r! B/ e) s
" g% O+ @. ^) ]" {" x0 `
[
本帖最后由 zw2004 于 2008-1-21 17:21 编辑
]
欢迎光临 捌玖网络工作室 (http://www.89w.org/)
Powered by Discuz! 7.2