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

|
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.# |" D5 F/ u6 g
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=. s0 I& p o" d, P5 K3 T) |3 Q
/**************表达式计算器************/
" E) v6 g6 z% e4 K#include <stdio.h>
- t* T6 E' a# K- B5 \9 ?#include <stdlib.h>( P% s9 y, p) I% W
#include <string.h>
* i3 w' d, m% y& e: Z#include <conio.h>
: M4 S0 C0 f3 R2 ^7 w#include <malloc.h>
) q) H5 i5 n7 H, h: c0 }7 y) Y9 n, h9 Z2 v" j% h
#define STACK_SIZE 100. y/ L1 P- K6 A1 _, p# p6 a
#define APPEND_SIZE 10) S( n6 b+ F. F# P
! `" n$ _& B! e, r s$ F
struct SNode{
. S" C& R8 v% Q7 g9 Q# S float data; /*存放操作数或者计算结果*/
. H& }4 @- K4 {. }" U( `4 o char ch; /*存放运算符*/
' L/ {! K E- N) d9 v s( U};; \0 i# x/ k( S7 d; T) T
. `4 D! u. v5 y q; Q$ d) C
struct Stack{% L& a$ W' Z& S! _& p
SNode *top;( L; v- s6 g& L5 [1 o% P p% b
SNode *base;5 d% h( r4 z3 q) t
int size;) `% j" @# X; Z3 v. z: `* O
};
: Q" ?, @+ z0 E4 @6 k
1 O+ M- N# q/ v& N1 t6 W/*栈操作函数*/
$ j) ~0 N( |+ a) Aint InitStack(Stack &S); /*创建栈*/
. ]* ~( o2 c& Y8 T. Qint DestroyStack(Stack &S); /*销毁栈*/& n0 \1 V7 i, G# d# r& R! a, V0 u
int ClearStack(Stack &S); /*清空栈*/: y% G& ?6 W; d# C
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/1 `5 ?% R/ q( b5 V& ?$ w
int Push(Stack &S,SNode e); /*将结点e压入栈*/! s) G2 _ m! o/ E/ L- k; s
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
) I' r1 ]5 b) o! x' |
0 b! i% W. k: F: ?7 I0 K/*表达式计算器相关函数*/
8 k- F( N; q$ V! T6 U9 @3 S& _char get_precede(char s,char c); /*判断运算符s和c的优先级*/, P" a" q9 i1 H5 _3 A' T
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/! g% w0 R, h% r% [0 s: J5 j; u
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/0 {$ n' r7 y8 k, _7 x
float compute(); /*表达式结算器主函数*/
+ b* l# v0 I# A0 s$ w2 uchar *killzero(float result); /*去掉结果后面的0*/ 5 C4 p, U- k# v, ~; H
8 X, B. K. X C
int InitStack(Stack &S)
$ [5 }0 B3 [3 H% j3 m! G+ D; Y( O{
% t' z& C# c3 Z5 ]4 Y S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));+ \% t+ y: v" Q9 B' ?
if(S.base==NULL)) U$ ~1 m( b4 b9 P( d( v) n- y
{; O+ Y4 }8 {3 `' F6 z
printf("动态分配内存失败!");
1 Z5 k* O# g& Q return -1;# u! C8 O5 ~$ N
}
( t* T9 p& v4 {" N- } S.top=S.base;/ Y6 O. r2 }4 A
S.size=STACK_SIZE;
! B: F7 j0 N& X9 e9 i return 0;+ i, I. [5 J( G
}4 o* }1 Y% W" ?& x) R9 a5 a
: l, w5 c2 b o2 L! m( M
int DestroyStack(Stack &S)
( H$ m/ ~5 f- Q% m1 s7 W8 x{
3 Y5 }1 f: [( W8 M+ X free(S.base);
* `8 O: |7 d- c! V- R return 0;" u! \: c$ i" `* W1 ~
}% q. Z; @9 v% Y
3 d1 w) @# w# \# ^- X
int ClearStack(Stack &S)
( o; H5 [+ `! C{
; P# h4 M) ~' J; L S.top=S.base;; v/ t" o) j2 { r* S* b
return 0;
6 G* w1 ^' x% k7 a}3 P- ` Z* r$ l/ O, K: T }
! a+ ?: J6 j6 k0 ?6 b& ]int GetTop(Stack S,SNode &e)) ?7 ^7 |/ j' g! V7 B+ a
{7 I' j, k( i5 ~9 `8 q& O
if(S.top==S.base)( c! n, j; v" e# w. i9 \4 _
{/ r+ o5 _7 `+ _$ V
printf("栈以为空!");" Z/ ?& m7 S/ J4 ?, ~
return -1;' u% {; b& Y7 E. J( l. t
}
: z+ n$ O" m# I& C e=*(S.top-1);
# q2 K7 x0 z0 s: q G3 q# t$ \9 P return 0;
3 d/ _& u' Z( v}6 n; U \ H9 y
6 @ x' r" w% c3 ]
int Push(Stack &S,SNode e)6 s* }; z4 e* a+ S
{
+ P7 q/ U7 c6 a if(S.top-S.base>=S.size)9 t r8 y+ j, O! L% f: \
{2 K% d5 s+ c7 y
S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
2 @- X: Y- P s( s7 h if(S.base==NULL)
: v$ s1 a0 A, |( H4 U8 ~+ d {4 E: L1 `# X* Z/ o+ v+ W. O" \: F
printf("动态分配内存失败!");
( o7 U& f( |2 K2 z, ?) s: O return -1;. T4 i! }& l+ H1 Y5 U# Q$ n
}
k, ]* L9 U D9 G' h6 W S.top=S.base+S.size;
2 Y5 A4 u" ]# f k6 ? S.size+=APPEND_SIZE;
1 u4 U# K$ _7 d5 S- E1 } }/ `% z8 c7 v, p. I! ]
*S.top=e;; H! V1 g( E9 s, @8 [. c" g
S.top++;4 M- p9 n" C# q# f b
return 0;
% v B& v9 Q. h! k) `. Z2 b! Y}
5 D% x6 c2 H+ j m7 ]+ F6 x( M L5 x: L, |! ` u! F
int Pop(Stack &S,SNode &e)* k8 p/ a U8 B
{
/ L+ o+ P+ X& G, r# x# T/ j2 s' D if(S.top==S.base)
% Q# h9 i) a" m0 G' y4 } {
% n& k# C/ }0 ? printf("栈为空!");
4 U P; |8 d! ]4 ?, x# y5 c7 R return -1;- w* D' F; S/ L+ R3 Y
}. O3 F3 a2 d$ \0 u
e=*(S.top-1);$ ~* `: |) L2 e! s
S.top--;
8 b' m4 M7 x8 z4 ^ return 0;
$ K \3 u# p, T/ Q. p% X}5 w1 s, K0 ^5 A) S; I9 u
R0 v4 I6 i: [) Achar get_precede(char s,char c)5 w/ d5 ~) u# |; Y; c7 `
{# `% W/ H& d9 h h; ?: B
switch(s)
8 \$ ]5 I5 b/ }* Y- |6 N* Y! ~8 u {
' u9 y# `, W9 z: B" Z case '+': ) n& n0 ^' x/ X0 d
case '-':
3 N" ]: s8 p5 R4 |" |( A7 a% q if(c=='+'||c=='-')% ~' S: P' K9 k, N2 r, w/ S0 t
return '>';+ j+ e x: G+ w7 {! _
else if(c=='*'||c=='/')1 d9 C- H, Z) z- T
return '<';( r" X: n; U+ M+ A% K# U7 q) C
else if(c=='(')
e8 i/ O" z0 k$ g$ Q1 ? return '<';
0 m$ z8 g7 s i$ z' _ else if(c==')')) c8 Y4 t% \8 r8 G6 U5 g) D
return '>';
! h% A3 Y- m) _' E else
! O( q$ I8 k& Z% U6 s& _ return '>';! y8 _- {2 P6 ^
case '*':
% R$ X! X& E+ f9 U case '/':4 ?2 n1 l& Q" {# d$ o$ I
if(c=='+'||c=='-')! L0 u; K/ }* \4 V7 J. I1 C% Y
return '>';: Y( S3 A5 l, B+ G% }* {
else if(c=='*'||c=='/')
$ O; z C7 r0 ^( K+ [ return '>';
3 P5 I) Q' j% e! T+ c else if(c=='(')
}9 }# L" s6 C% d return '<';
6 Y6 m3 Z6 ?3 S else if(c==')')7 T/ o8 ]; `, |" c7 y
return '>';
+ ~2 Z9 C) V! Q+ I else- V/ y$ w y# {/ Y9 [
return '>';9 W% p y" i6 H: O% u
case '(':
* w3 s5 ?6 `0 r" G if(c=='+'||c=='-')" J x# W9 S ^2 R' W0 M) X6 G
return '<';
}5 e" H' L7 Q1 `8 }, U7 L else if(c=='*'||c=='/')
9 r. e. J+ S1 z X* g5 ~ return '<';
, a# k4 G4 Y* n: U else if(c=='('). \9 v( u5 R+ F @9 D
return '<';
1 a1 }/ e$ `8 { else if(c==')')) i' I9 u8 m u6 L9 L- J
return '=';
6 v+ {6 @0 ^+ e! Q else2 d" ~$ V V2 ^: ]
return 'E';
# u$ {! I/ ^. z: X9 ^ case ')':
$ M8 X& i U. ^+ a D# G if(c=='+'||c=='-')& W0 s+ C9 t1 n/ s6 _0 A. \
return '>';3 S, j3 a3 R- t6 M: v0 r4 T
else if(c=='*'||c=='/')1 r4 T+ G9 L3 R6 k& S
return '>';
, @$ t: F8 O* T, T+ }# i else if(c=='('), K* ?. s7 s6 m& U( `, D5 H" \4 |
return 'E';+ x* Y( K( ?. G6 O: @" ~6 J& K
else if(c==')')
/ S6 j# R& D4 V( F$ B9 N& i" p c return '>';8 O% G, m9 Y* i k' {- l, I* D, ^
else5 [- @& P0 ]3 E* I! @8 X H$ F
return '>';
2 Z/ P0 a A/ Y# U9 ^* b- s3 ? case '#':
- M* @6 |/ A$ Q" q, H2 X if(c=='+'||c=='-')
, x8 R# N8 {2 U* V4 m$ h8 v2 i2 w return '<';1 s' c1 h8 X m9 S3 X, e
else if(c=='*'||c=='/')
3 S. L; o. {9 U return '<'; y- u0 V0 T- F6 J2 W
else if(c=='(')$ }2 g" x- B0 T/ F* _1 B
return '<';0 m# w8 u4 l) L* E3 G' D" y# ?
else if(c==')'): J0 N, {. P. E( P
return 'E';, ^) R; Z! L. r3 h7 z; U
else, ]: w }. e2 I% ?/ ?( F' H
return '=';
) }& H7 e% m. B! Q! M" X default:
' q0 a+ r( _ d% H e& N: ` break;! ^4 x& }4 W m/ Q1 t' d
}1 e4 A/ P/ g* a% B% Q
return 0;
! \; s" T# i5 E; h! h- B}* i$ ~# O# X7 n. N! Q5 w7 B
- S) N$ W0 Q9 m: ~% @$ `int isOpr(char c)
9 A& Z( c/ s$ [; U{
. p K* G& t, S3 ~4 x if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
9 D5 R, J6 _% H: c' r8 m return 0;9 k. z/ b5 e# T( v, u J2 T7 m
else : ~8 b. i; y) B& R
return 1;
$ G& L: X# t. }0 S, {}
1 r) _! u8 Z2 M2 M! m
0 \- }. {5 ?$ s+ r% Bfloat operate(float x, char opr, float y)
( R/ z ?6 ]+ ^2 V4 ?{
; H5 A: q6 W& \6 \; N float result;3 e; [9 k; ~( s& t6 Z& ?
switch (opr)
+ v; I5 r( }6 j6 T( O) t8 i {
4 U$ z7 R" e2 r5 P8 F6 \" ` case '+': & ^+ i: `5 Y; @" ?8 _3 x* A
result = x + y;
; }' Q% B, [/ C3 H, R break;
* G7 W9 l& p! W* Q( m/ h# Z9 Q. | case '-':
- ^% E. h; y! V result = x - y;
0 S) Q) Z/ J+ L, c y break;
3 [- K* }, `( x& D- S7 V/ \ case '*':
1 f3 }# [8 L* m8 k% i result = x * y;( J6 j( K; c% G6 x# v/ s
break;
& l! {8 c' m+ T0 t case '/':
* v1 }8 Q4 e t+ k if (y == 0)
- \7 `4 \( a* u- ~+ r( h9 { {, P) O0 \: K2 a
printf("Divided by zero!\n");
& ~$ B' m* ?( d- \ return 0;
! ^1 o, C& p9 }9 E& A x }
$ \# _/ y2 ~& V8 {2 U9 A8 w0 T else. Q# h$ m" ^9 A* v2 A
{% _, U+ L( I' C9 T: ]: r
result = x / y;4 ~7 l+ M& z8 f( y A4 w% G
break;
5 s6 P- f* Y8 m& G9 o$ r( t4 u' w3 Y }
& ~# V9 M9 f1 [! g8 f. k" f default:
# J% s9 m9 k9 i+ n9 _, ^ printf("Bad Input.\n"); 9 x$ L4 y% u5 T/ E1 N0 o
return 0;1 r" M% b! o; m) @9 ~3 r4 c9 x
}2 i x7 q, o5 J* Q ?
return result;
0 O2 G. n3 ?7 J} 6 W4 J* q8 E' |& @/ c1 Y8 Y
( q; B( m. y& j, y2 M5 ~# q, m2 @2 N
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/3 e" q9 s8 q6 O- {9 n$ e7 r
{
+ W+ t# m+ Q* x8 l1 T Stack optr,opnd;$ V0 W2 x" ~) Q. A# @2 b
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;8 z$ N' Q! I. J/ W
char c;
1 T, I' W4 N# u; O8 |7 n char buf[16];
! C8 F+ I" I% j. A% J9 j, x int i=0;
H) ^, H5 C% n1 Q- R - @8 v. }% [2 C8 ?0 ]2 k
InitStack(optr); /*用于寄存运算符*/
, O1 y$ a) v+ ?0 c5 f$ Y InitStack(opnd); /*用于寄存操作数和计算结果*/. y- g* H7 i c2 y4 `
memset(buf,0,sizeof(buf));
9 `& [0 G5 d. R: i 8 i6 F; a: u7 O% y
printf("Enter your expression:");
4 Z1 F9 M; h& {. o, ? l# @# {
4 ?( e" Y" B6 d0 U, I opr_in.ch='#';
0 _; C7 _$ }$ Z6 W( @3 @! E Push(optr,opr_in); /*'#'入栈*/
2 r1 C) A% r& u2 ]1 r2 X GetTop(optr,opr_top);+ ^0 y9 d+ g' I% k5 G
c=getchar();
7 k3 z1 z, e! A+ v) y: P5 r8 X! N' V while(c!='='||opr_top.ch!='#')
* ]8 E/ w9 g* s/ ]- b {. r% ?- g! o2 }
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/$ q5 o5 Y; |& M5 F1 [/ Y
{$ F, N0 q6 `# a& m' Y
buf=c;
) p) @# {; ~9 k- }' P' l# ` i++;
) y2 U, A) J; u2 D% b+ b c=getchar();* x6 A, S3 m0 m
}" { b: w, r" P, `6 h
else /*是运算符*/
* J. G) r) Y1 m( g) s {
/ f8 I2 x* e6 O1 b: w2 n5 ^. k" }+ B buf='\0';
" I" V* V3 z9 a; o: d9 N if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/& ]; ` K+ e: k! v& _7 x
{- [. J0 o$ g2 z8 [. P" n" Y
opn_in.data=(float)atof(buf);
8 f& V* L) E7 w) W8 o# r Push(opnd,opn_in);
! U3 F, t5 o f1 q( V/ G/ Q printf("opnd入栈:[%f]\n",opn_in.data);- e4 g! @* o( a
i=0;
+ v8 o8 {' q9 g |6 {, c memset(buf,0,sizeof(buf));7 Q2 h; r# \' _* S
}2 p9 ?' {% K- ^ d
opr_in.ch=c;- {# T& m- Z b. |0 a0 j
switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/) B- M8 H& p- t, Q4 K E
{9 g$ k. q: ]- D/ {
case '<': /*优先级小于栈顶结点,则运算符入栈*/: k/ |3 K4 x W3 `2 t7 V, Y4 V! M
Push(optr,opr_in);; i+ z+ Q! K. @: C e: b
printf("optr入栈:[%c]\n",opr_in.ch);( r! L+ M( l$ z5 X. }. P% d
c=getchar();
4 O( ^3 {) F, q$ F' }$ { break;
$ c" g' G- n4 D" ]4 o6 F+ r; Q' V- _# H case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/5 T7 `5 F" Z+ O
Pop(optr,e);' c& k7 U4 B8 B3 U8 N' l* }
printf("optr出栈:去掉括号\n");, _) A! Y$ h2 B- ~3 G$ q* t
c=getchar();4 Z: e9 ^$ y2 |7 S0 I/ r" t
break;
0 H9 k7 Y0 G; E; Z% A ?& C case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/, K/ {9 x T7 {3 y: d" J0 G
Pop(optr,opr_t); Q& n( v/ Q" H- v# }+ `
printf("optr出栈:[%c]\n",opr_t.ch);
/ w" R7 V, C+ B4 C( J4 ^- J: G if(Pop(opnd,b)<0)2 G8 @6 d4 f7 v8 H, ]
{' A- u6 }( M0 G
printf("Bad Input!\n");7 ^: q6 H* s. D1 E: z Q: W) N
fflush(stdin);) u ]" V& w. Z0 p$ `! `
return -1;# h: @! {1 }& H& z, q$ S2 [. l
}
0 T) a% A+ |+ Q# w3 {7 T printf("opnd出栈:[%f]\n",b.data);
( {0 n# P) V9 V2 B' y. S3 \1 Y* _; x if(Pop(opnd,a)<0)
+ C3 I$ D9 B) P: Z k4 v) R5 C {* u" h. G; R* ~, d5 A
printf("Bad Input!\n");! S$ S$ ? q$ P$ V x2 [: X& T7 f
fflush(stdin);& W: j) B1 X' W, q% y7 I5 M
return -1;
t! ]6 V3 o/ [' l0 V }2 C- l4 j, N) B4 o
printf("opnd出栈:[%f]\n",a.data);1 |0 Q6 n3 `# Z8 Z5 m
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
3 }) b! h: d1 r. X% ?+ t Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/; v$ _3 y) ~: \0 x6 Y% a) G
printf("结果入栈:[%f]\n",opn_tmp.data);
( y& A' V7 Y3 @4 R2 H) t( u6 z0 G break;1 E$ D. C+ v! `' E Y/ `
}. i4 G$ p7 X3 \7 }/ T( p5 `; |
}
( V7 j0 V) T6 }% f# E7 e: ?, | GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
! V7 i; z" _! P* k7 J. e6 E }
# {* |+ _- f, ` GetTop(opnd,opn_tmp);/ S0 N* H7 T' d0 C' A. T \/ W
DestroyStack(optr);
! P6 W# ~0 c+ b5 |" f DestroyStack(opnd);
' O2 F# P% S0 \- i) ^ return opn_tmp.data;
, t: u( L+ I/ x4 N}/ v, G; M) f3 S! J" U
) n4 s% {0 b( |; W
char *killzero(char *res,float result)! s8 m1 x" G7 h) y- x
{6 @' U5 }; w: v7 s9 O: h8 d' j
int i;# i! w( V- g/ V7 o* o
$ w0 c) ?8 R" o* J6 T1 }2 h; d& Z
sprintf(res,"%f",result);2 @: | b( p3 Q* W* t" k0 ]! g9 H
i=(int)strlen(res)-1;
" z7 j* _) N' } while(i&&res=='0')
U6 B, [$ j: b2 l- f- q1 `) f {7 T! t0 Q" _. q
res='\0';* b ^9 p( h+ B- T8 r* z* W
i--;- V; r3 y$ ]# g) B% b/ f
}$ F1 w% V9 I- c' ?; ]' `0 Z! U
if(res=='.')- q( W& I# i! j I! ?
res='\0';- r' b8 F& a( q2 _
return res;
& I% ]: B; V$ i* v: n}
* X$ g( i$ ]) @5 g8 |: o. Y4 J2 G, C
int main()
* Y5 t% z# a0 t" |/ \6 j |0 r{
0 v" Y8 W9 J' q char ch;
. x4 ^5 ^5 P! M! s, y$ d1 w char res[64];6 I y5 ]2 D4 s8 p# J" Z$ }
float result;$ }0 ?. R1 s$ t, l t% ]
while(1)/ A1 _5 `7 f. f: V9 m8 \
{! j* f0 {' T7 Y" l; L: F3 a) G! J0 W
result=compute();$ R# j, j8 U2 A; k
printf("\nThe result is:%s\n",killzero(res,result));) ^/ j- \: ?& N2 j8 b9 k
printf("Do you want to continue(y/n)?:") ;
. S1 l0 U1 _$ a" B' p+ a ch=getch();" r* P+ T0 G& ~4 c
putchar(ch);
( X7 T! T2 x( \# L% f if(ch=='n'||ch=='N') @; V" M0 X5 b; J9 ]% b. X
break;
; @ B! I9 C S' c0 ?. D else* n( o2 [/ B* e9 |% J
system("cls");
m3 B9 Z$ n2 L; Q, H }
: K- q+ \1 L( k" B/ P2 a/ x return 0;0 y" r7 C$ o! E% D! R5 J% `& G! }
}$ O1 `; y5 q5 `# J: f. I
- ]% c' B$ e) P# K* ~/ p[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ] |
|