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

|
C语言表达式计算器
为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
8 Z& J1 ~- ^6 [; r" w2 C2 Q程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=* I: \( K) K7 o% P' \; p1 B9 p
/**************表达式计算器************/
* g8 h! u/ r3 o. ]( ~. l: [8 _% O#include <stdio.h>
, D3 b5 W( `0 V8 `#include <stdlib.h>9 r+ D. y4 u: U) q7 |, Q
#include <string.h>) q$ A9 b7 @8 D# s* S* X
#include <conio.h>
; D$ `' t/ N0 f! z: R#include <malloc.h>$ W2 f: K X: e0 n3 s$ o' N8 s
) S, F/ E& F4 h/ O, X; w# c+ Y% @* V#define STACK_SIZE 100/ U% g& ~* v' N/ Z
#define APPEND_SIZE 10- \) N! M( ]0 {* Z, ]- r& S& z
% g; t! \7 I# ]9 k6 K0 Y2 n
struct SNode{3 \* S8 y& \! ^1 x( \
float data; /*存放操作数或者计算结果*/
: c; m) u4 v1 `/ _. P5 T9 m- L char ch; /*存放运算符*/1 B/ `: }3 a2 r2 w+ M3 C4 g
};6 ~: Z) \6 ^& I- ?/ A
! Z$ ]0 ^ {, k0 |1 e3 ~struct Stack{3 Q% d) x# |& R9 h* w5 X- Z5 F+ C, x
SNode *top;
/ E, |/ S$ l; ~( r! @% s$ j: K SNode *base;
( O" n6 e0 P9 g: x: p! e$ D+ A int size;. d/ i; ^* a, z3 I6 F8 B. ]
};
M L* T, j# ~& f" @) a1 {# |) M, E# ]' c1 y1 L4 }4 O; D2 ?# L+ W
/*栈操作函数*/ ?' v6 I* T; \5 [& L( x: Q
int InitStack(Stack &S); /*创建栈*/, Y& Q0 q6 b' c- J Q5 }
int DestroyStack(Stack &S); /*销毁栈*/6 b- U' I. w. i" V6 E$ e
int ClearStack(Stack &S); /*清空栈*/0 C( o- |: j* `3 G/ _# N
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
# R) I& I7 @( B8 h, \ z" Iint Push(Stack &S,SNode e); /*将结点e压入栈*/
* ]3 l5 h( h) N$ [int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/- [, J% r1 K" y. P
. D+ D+ S" m+ J* [' S5 I) y/*表达式计算器相关函数*/
; n+ ^0 ^0 w4 y7 l j' ?char get_precede(char s,char c); /*判断运算符s和c的优先级*/
: o) r5 I4 k+ K" P# Q6 |1 l! Dint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/1 d3 R X$ k/ Q' t9 n2 \5 m
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
+ m; p' E& W% j: a, P# y0 i8 sfloat compute(); /*表达式结算器主函数*/
5 {- y4 t/ H1 [char *killzero(float result); /*去掉结果后面的0*/ h; o% B' e5 @2 W2 Y3 e# Q- z
8 \. ]; L/ Q& l* B1 L& `int InitStack(Stack &S)
# a5 @$ r; o! u( _; X. K' ?{
. Y" p4 W! |4 w( U8 u4 A S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));) p9 q1 k* j9 H- j
if(S.base==NULL)
# r$ e7 O! r, t) w5 I: Y {
7 \0 J# [# V" i4 p* R: s printf("动态分配内存失败!");
e9 u& y! `3 | return -1;6 `. a( a' {- m* L
}
$ C7 `; K% [# I* w0 B S.top=S.base;
; d1 y- x6 z1 m+ }* a S.size=STACK_SIZE;
8 b6 t6 e; z4 z( g return 0;" d; C( `, N# l) v( G4 E5 o6 Q
}: p( M7 g) v/ I, G
$ F# H; Q0 s2 d/ H2 S$ @4 f' L
int DestroyStack(Stack &S)
# i Z' S8 D. Z3 |% B* _{7 Q2 R3 M: ]/ S; P" N& H6 B
free(S.base);4 L' s o7 I/ K& \
return 0;
: B3 V$ o# s7 K5 L d6 C: ?}! H# [1 V% v" M/ ~9 E% {6 O9 x
' N2 ~1 w6 W) I0 n M z& Q
int ClearStack(Stack &S)
& p3 K2 b+ P+ Q6 E4 {7 ]2 c{
/ ]5 J$ W4 u9 D. o! y$ S# l$ E S.top=S.base;
/ H& d, m) ^: U0 l2 F9 p: V return 0;
4 g% p: g/ Z5 C% g}
: ], H" y Z! Z3 }# F- I8 A$ b" Z# }6 E
int GetTop(Stack S,SNode &e)
4 O) l" p* D1 { w) @. J3 `! W{7 g) e/ a" r* y( V/ L2 j5 D
if(S.top==S.base)
; s; D2 r% z/ U: y$ ^7 ^" x { v, N3 X2 X: ~9 L7 e
printf("栈以为空!");
: ~7 Z$ h" Y$ O9 s return -1;! [) W, y/ x" f( U/ P: J- d5 E3 M$ h/ Q
}- [# `, ?$ V, Q# U4 g- K) }4 q$ Z9 d
e=*(S.top-1);& x2 I0 P; }- D y9 i% p; P
return 0;& q* D5 x" |" t2 R
}
1 n* F" a& D! F! J# Z/ E# B% y' j, t3 B, o# W. R
int Push(Stack &S,SNode e)
4 |" Y9 j" N; D0 w{9 ^) ]( v; I I3 C! l. b- @
if(S.top-S.base>=S.size). A- p2 e7 F- ~* {
{
- A% e0 ^% }, d _6 u S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));% K( P% L: Y4 _/ n1 q
if(S.base==NULL)) h) I4 l6 T. a7 j- H B
{% y$ e# E3 u/ x7 U& y& w7 g. z1 ~
printf("动态分配内存失败!");
( L# o h0 n$ X& T; m5 b return -1;9 d P9 I% A( o1 \
}& H- U- l5 f. w# R
S.top=S.base+S.size;
2 a, ~8 i7 h& B) F- B3 Z/ ]5 z- G S.size+=APPEND_SIZE;% x$ r6 H( s9 H( q# P
}# T. ?) o% v2 C
*S.top=e;3 g* D2 t" o. c$ R' L
S.top++;0 B+ N& N# `, h4 P( Y
return 0;
: o) I0 x+ O4 t}; D6 m j2 I& |: p! z
/ _, B+ L* `8 V$ dint Pop(Stack &S,SNode &e)
/ {3 E# L; j k" O{5 g2 X7 c, d7 c/ i# _; U1 K& q
if(S.top==S.base)1 I2 c2 B& `' O- q& J1 ]5 ?& B
{
+ m& D0 h+ J1 k; H8 Z printf("栈为空!");
7 M5 M) z7 d% j0 r j2 i return -1;
( I* j; L: {0 C4 Y }
- }+ n0 A, L \) _/ b9 ~ e=*(S.top-1);3 Z) _8 m; v' x* K! v
S.top--;
. H- N! N, Y1 G3 e6 e+ U4 a4 K return 0;& h- H- ?4 I% p/ _" t9 M
}
; r% O6 x3 J$ r3 V- I* X2 ]7 G6 i2 F) h% M" t7 t7 @
char get_precede(char s,char c)
, v3 _1 w A. L+ m{8 R1 }; x3 U: l: H" t- }
switch(s)& a$ B6 L/ X$ Q
{+ g6 \1 h& O. v
case '+':
1 j( T5 |; O6 K) r2 { case '-':, p' M9 [9 r- e9 S
if(c=='+'||c=='-')
! D2 Z- s4 {2 k2 ?0 L s/ [2 _ return '>';
4 W- \6 A7 P) K4 ~" i else if(c=='*'||c=='/')- F, D3 b0 w: d7 s- E+ |. ^+ O
return '<';% R4 j+ {" o! f* F+ c, {" U" X
else if(c=='(')" G9 Z- F4 i$ S8 W/ ~4 a- V5 @) E
return '<';' a4 j# |9 i B7 E1 X
else if(c==')')9 b2 N* ~8 G$ F. Z+ r P
return '>';
; o3 o8 ~% Y& s3 D2 m* b7 z else
4 `1 g# B, U0 m( }$ \ return '>';1 S* I4 G, `8 m8 m/ \" }+ x
case '*':
5 I! O+ R" u7 M% v case '/':
0 K. g0 Y# Q" w+ u+ Y5 f( I4 m if(c=='+'||c=='-')( L# z" n) O+ e1 ?4 J/ g( M
return '>';
- c! Y3 q' K: ]2 m: `; k else if(c=='*'||c=='/')0 `- B4 w5 e6 @
return '>';* r% U5 n3 B* `' _8 L
else if(c=='(')+ @* v, g- R5 D) D& v
return '<';' g/ v0 U4 b$ e+ `
else if(c==')')* [; |) J8 A! g. v$ \
return '>';' V# z1 H. p E( u' x- x& R% D. A
else
& K' B' o Y( D return '>';5 o0 u9 w& x% R8 @; D3 m# k2 r
case '(':
* @3 J& y9 a/ k: D# G if(c=='+'||c=='-')$ V& r8 d p9 C& @6 [
return '<';
6 J' }# N6 r# L! g8 j0 Q else if(c=='*'||c=='/')
* u0 O% v* l! \2 Z1 q return '<';( j+ d) _3 { G
else if(c=='('). U4 Y. p1 P( I8 h: Q
return '<';7 x8 R- L. _* Y, s
else if(c==')')
$ d- ]' K! t0 |' s" a- D return '=';
5 I1 n3 K$ }1 Y% k4 B& @ else) d7 |- X; E! x O/ U( i5 r
return 'E';9 L/ r3 x, O; c' Z Z3 r
case ')':
' F- D! v2 H" g; }; p, t0 O3 \ if(c=='+'||c=='-')
: u' j9 z, U- b- E" A return '>';
+ r8 K/ v7 h% ], ]1 l$ r' K else if(c=='*'||c=='/')
. v1 l0 p1 O' ~6 M! i' M return '>';
( J. {1 U; E( E+ s, N* ] else if(c=='(')
0 u2 L, A0 E& ~# o% X0 ?- x return 'E';. f. T$ L. o- c" G
else if(c==')')8 Z8 f9 X" T! D* J
return '>';$ v1 U S9 B$ D
else
5 J* _$ E8 f: r2 r8 O+ F return '>';+ H3 k2 F% h2 Y
case '#':
3 l5 D1 |6 u' `% B5 D, F4 a if(c=='+'||c=='-')
# i' C" p6 N. d7 o ] return '<';
2 r, T! A. O8 b" s4 w r/ r else if(c=='*'||c=='/')
& N( \) ^& S$ p return '<';1 T0 M$ {# M+ m/ Y5 Y
else if(c=='(')/ n2 n1 q5 s2 a7 ?( }. W/ P- t
return '<';+ G' F) B6 R& m6 s
else if(c==')')
, {& x: r* }2 K9 D. a. ^: M3 | return 'E';
1 e% z J& g }8 U! O/ R& x else+ S( a; s6 q, S* y2 O5 H
return '=';. W: R8 S [: f
default:5 A4 Z0 e$ O O" | V3 X
break;4 a- z: }& ?- `
}
5 W- X# V8 b6 H$ _ return 0; 2 H5 C- }, b5 s( ~# v7 N
}1 h4 Z, c& z/ D8 j! V$ S X
: V, a$ r1 H9 T6 N2 V3 Y9 Pint isOpr(char c)) r! t# T% N/ O! `" F b, q6 H
{
: `" I9 H9 i) y! } if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')$ f, R) a" H4 _) p
return 0;
+ P8 ^/ v& f+ i! h4 i else / P, D& w1 T0 B) G1 ?; Y6 A: j
return 1;) y" L; A) T7 o( d
}9 Y7 V* r5 ^9 V4 |! H7 J# c' m! R
' O$ j7 x8 c0 o3 Z, @6 {9 ~6 kfloat operate(float x, char opr, float y)
+ Y7 z$ s( A* c8 R{
% P% r, h* ~7 y: Z: l9 D' m float result;, X p, ` ^8 p, [, M+ O- J
switch (opr)
0 _# A7 D2 Z% U, f- ]4 w* i" O {
# y; \3 }7 E% D- P case '+': / S# b; Z5 j/ O0 Q) f% q/ c! _0 ^
result = x + y;2 a, d- R; l2 `: R
break;
2 C2 d6 s4 Z" L case '-':
4 ~2 t9 Y0 o# O9 L result = x - y;
3 I/ l3 {' k# G- i+ r' z3 ^ break;) A! n6 L7 [# e9 f
case '*':
# |9 f$ w$ S/ z: _# M. ] result = x * y;
$ x$ ~+ {( q2 a& B$ n4 O/ E break;) d$ m* t) m- p. _+ n
case '/':
* I; n6 {! s8 T6 y2 y. m7 d- J if (y == 0)- _; n% B5 L9 f2 x; u) z3 }
{& m- ~4 d8 ^, s! n( g6 M
printf("Divided by zero!\n");9 @. C0 P1 N8 d) A* s0 w
return 0;
, g4 ^- j9 r. M& L }: a# i8 |' z. [* u O
else
6 C# _6 z5 y0 Z) D6 r" } {
- Y: P: W: H, A( R& \# d3 [ result = x / y;
$ x% }- Z: t1 L) t break;
% e7 [) `( i3 F }3 [8 }0 Y& H* k2 ]- ?2 h9 P
default:
4 t8 a- Y3 d/ I& v+ X printf("Bad Input.\n"); 0 w2 q/ x9 q9 Z5 \: W2 o
return 0;
% l8 {. {, f5 g: l }: Q9 {6 o7 z) c8 W4 X+ t/ z; m
return result;
1 Y3 h5 ~4 e! p9 ]}
/ Z: g+ g% B0 A, |# f! Q5 o1 a& m( n& C- C( E8 Y
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/% F( e. N' z8 v; E1 s2 Q0 R4 R$ h
{. r3 t& y4 F( h* _0 R9 r
Stack optr,opnd;9 K2 A% B* _; q
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
~* L) Q, n" Y+ T char c;
, {8 y+ B$ \* g& l char buf[16];
% I V5 \# X/ }3 }- W) Y int i=0;4 H: |/ s" o" Y! z$ i. ?# q% j
% H L' p- I9 H$ |7 u
InitStack(optr); /*用于寄存运算符*/+ m- a5 t" O, K7 [4 R
InitStack(opnd); /*用于寄存操作数和计算结果*/( j2 N! e) v; T# A3 K& R' d* b( D
memset(buf,0,sizeof(buf));" \. m' J% n6 w
( L6 v$ ~; K& j- I4 T" v printf("Enter your expression:");
3 k1 N7 Y0 Z1 E 8 _. S9 M& \; J! z. m; T/ U# x
opr_in.ch='#';: H p; |# S& O$ w
Push(optr,opr_in); /*'#'入栈*/
$ k$ ~- e; k; k8 c GetTop(optr,opr_top);
" m( r5 d9 o$ L; g7 X; x1 i9 w) j c=getchar();
3 o B& \1 u ~0 d1 | while(c!='='||opr_top.ch!='#')
$ O) E, r- ?( ^& s {- x2 l8 p5 b W$ P# e! m9 }7 l% O
if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
6 c, q- O3 O+ d& S8 M {7 a0 `$ O$ W {; M* n1 Z
buf=c;
" M4 {* P; o' [) {' W; L i++;
$ U4 U9 @8 J' A- U t- O c=getchar();8 A2 r: \: I# J7 \+ r
}1 B5 x$ B5 v) U; v- S, w# y
else /*是运算符*/( R$ @8 k2 m" w( t6 Z% b2 _
{" C" F" k1 _- U5 ^. e
buf='\0';. _* C+ \# X& j: g& W
if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
4 b7 Q$ }( n/ A+ p+ d {, J0 n( e) C: D' W6 j3 I
opn_in.data=(float)atof(buf);
( Z' v" U5 \; n5 ^! e) v* D Push(opnd,opn_in);' ?) Q/ s; i3 Z0 W0 L9 A' ] c
printf("opnd入栈:[%f]\n",opn_in.data);
h& B3 b* E. q; h( `6 I5 \9 b. o i=0;
. q- S& y7 F: L1 q memset(buf,0,sizeof(buf));
5 l5 q; y! x8 x }0 V% S* A; B2 u. a
opr_in.ch=c;4 ?6 h3 i5 i; p
switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/! l. z! B9 L1 I" P% n0 o6 c
{2 h2 y) G5 I7 N. _! I" q, g' L
case '<': /*优先级小于栈顶结点,则运算符入栈*/; o! @: T l u, i& g
Push(optr,opr_in);
: m$ M( D% }) T: X6 G7 D0 P printf("optr入栈:[%c]\n",opr_in.ch);
& N) S! M% |* ^" g% N4 y+ T6 U! P2 b c=getchar();
" ?' u. E" B) s& B" j break;; B' p- V( C3 |0 J$ g
case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
. p6 t# k% k8 b' \* }3 n Pop(optr,e);6 ^+ N/ c7 F. V3 {
printf("optr出栈:去掉括号\n");
7 q- q# V! }* o3 I c=getchar();7 E' \; z% T7 O! R
break;
8 A! N/ a+ e" @: z% L9 C% s, { case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
2 B6 Z! {; d! w; h Pop(optr,opr_t);2 ]& I/ q2 B$ w" }3 }, ]
printf("optr出栈:[%c]\n",opr_t.ch);
$ D9 I: E1 Y* L" r z5 A2 w& p if(Pop(opnd,b)<0), f# I U' {- I' r; p2 ~8 x+ t* X
{2 H( y% {& C3 N: s, `
printf("Bad Input!\n");1 @" m) U: K9 V! u3 _# L! U( o
fflush(stdin);
/ o( S5 ^0 m' @" l! m return -1;, P/ `. n( s# I/ `
}# o/ s" q6 u7 q1 M5 n! d
printf("opnd出栈:[%f]\n",b.data);) c1 q' K% j( H* t8 u0 [- v* e3 g& K
if(Pop(opnd,a)<0)/ V5 ~' I: a3 l) C# r# L: ^6 C
{
; r4 p* b: y, Z, w2 Y/ A# O6 Q printf("Bad Input!\n");5 o) r3 U7 ^: A" }7 V
fflush(stdin);
: {2 X% w6 K) M return -1;
" K) n+ C/ y+ ]; c& C }
/ t. H* z' g& ^ printf("opnd出栈:[%f]\n",a.data);8 p) g! X5 ~' o1 g8 H. }# K6 ^
opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
' J1 s" S2 g; q% q! \8 U) M$ \" | Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
3 N2 b0 t3 X- Z: x/ b printf("结果入栈:[%f]\n",opn_tmp.data);
. } P% C( b3 ]+ R* l break;
0 i7 K0 x; q, a; v3 b }
. p3 ~' j0 H; t& @# \$ h- x2 l }1 T/ n: d+ j1 Q6 E0 q" ~6 B
GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/ ; p5 ~* T1 r. A) G5 f2 i& F2 O. c4 O
}
# |3 v* u U5 o* S/ s GetTop(opnd,opn_tmp);
8 M& O$ o% o! X6 \6 ~/ o: @4 Z DestroyStack(optr);: H6 N* C9 h- S( b; c( v4 @
DestroyStack(opnd);8 z* R' Y8 h. Y
return opn_tmp.data;
5 s- k" e9 ~( ?* l& @4 j}) x+ e6 d! U* ]
/ Z: |1 `. U% [4 {* Uchar *killzero(char *res,float result)0 [; x) b9 s0 E* H% ]- L
{0 k' @3 _3 O# z& n$ T( h
int i;& R' [0 a3 X0 @5 v2 ~
# K: k# _) y2 e% Q, x/ _6 z) i' \& K$ x' W sprintf(res,"%f",result);7 |3 Y! W- j4 j8 {' ^
i=(int)strlen(res)-1;
! _' u$ C# \: n, X4 ]2 e while(i&&res=='0')) S3 Z n4 k; m! a; l1 J
{
, W4 ~. C0 `1 u& W6 U res='\0';* F$ G+ |, p5 g& ]% b
i--;7 g5 h4 Y. Q) ], k8 n% A& c: i9 w2 S' G
}
. e1 S |. }6 A/ ]% l. w if(res=='.'); F3 K: f+ f/ Y' I+ n2 [8 R
res='\0';; ?) N% U& f( i5 f* z8 i
return res;
$ O; k+ P. c9 D8 d}
0 i1 y( T5 V- Q3 t F4 R ^
" e- u( m" Z. {4 A5 rint main()
3 u: M0 P7 `3 ?1 Q9 |$ G{
! f+ X; v8 ~$ P" C) a char ch;
. o" T( C0 c6 N) u* B char res[64];
2 d* j! [) h. p0 Q float result;6 m/ Z% R. N& W: }" ^7 I) q3 ~
while(1)
; U$ M+ l$ o( E7 G* n: g {) x& {$ d; b, e% y/ F; _
result=compute();
& Z& k7 W/ N, a' j printf("\nThe result is:%s\n",killzero(res,result));
) b- I% _" y9 N. Z printf("Do you want to continue(y/n)?:") ;
# n9 }; M7 |0 o5 [" T ch=getch();
) P: ?% w# a0 D& m& n3 O putchar(ch);9 s' g( C9 U( e. i9 z, O
if(ch=='n'||ch=='N')
9 [- ^ A5 b/ V1 E9 c& y break;
9 g* ? z/ a: S else; C2 M$ Q/ O, i8 B% U$ M( V& s+ v
system("cls");
. e: U4 x; N3 B2 r# q1 Z }+ C2 N. ]8 u/ ~" I# K/ U
return 0;
* | x, ?: e( ?}& e4 B% b% ^ E2 a& A/ S
1 X$ S2 u8 |, O5 r, [1 M
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ] |
|