返回列表 发帖

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
/ n$ _& T8 N0 Y( u/ t5 a. U程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
. Q3 t! I& `. r: `  w( t/**************表达式计算器************/
3 ^' p+ N/ U2 F2 R- u! T4 O& D#include <stdio.h>: }# M2 c5 J2 L4 J+ }  h. H
#include <stdlib.h>& o; F2 {, ^7 N; q
#include <string.h>( E1 b4 z4 f& e
#include <conio.h>
5 u9 C5 V- @( s: ^3 V" [# b#include <malloc.h>3 r# q$ s0 V# F- B
( F. h; d; ]; a- ]8 _
#define STACK_SIZE 100
( @9 |( D) R7 L" j1 c# I#define APPEND_SIZE 10( i0 O. Q. x+ @7 }

9 o- h* T) N- |; K1 kstruct SNode{
& a* o  w6 l  [+ R0 Y- t) E    float data; /*存放操作数或者计算结果*/
" D# }7 |3 d! D* q: i, S3 c    char ch; /*存放运算符*/
8 R& r  [0 ~% }- ~# i, g};
& r( c- }: Y& b' X/ V
9 Q  y# Y3 h/ p8 x' k4 s6 Z* W+ Z7 t, {struct Stack{
) A- _% o2 Z; h( i6 P    SNode *top;1 ^8 `5 K8 k. g8 ?% D
    SNode *base;
/ A4 V! S" _# c' q* p. z+ I    int size;" i2 N* _( y0 w' n* t7 w5 O
};0 o2 l( G8 V# {/ r8 a' l
- h6 k3 s7 f- i$ D" O1 e
/*栈操作函数*/
9 w9 }" q6 l$ Y+ N: u1 ~4 Qint InitStack(Stack &S); /*创建栈*/& a; P: y% E4 {  M
int DestroyStack(Stack &S); /*销毁栈*/
& j8 d. d; T1 ^! W% U6 sint ClearStack(Stack &S); /*清空栈*/
+ ?, f  U8 T! F" Y$ Z/ W( m6 lint GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
. n1 ~/ u3 A: H; m; qint Push(Stack &S,SNode e); /*将结点e压入栈*// ]8 y' Q8 s8 l
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/0 J- D2 z2 d, l9 r2 F+ }
- Q) _* V. c3 V% _6 U/ e6 \' v- p
/*表达式计算器相关函数*/8 s5 L, t) H; U
char get_precede(char s,char c); /*判断运算符s和c的优先级*// ?  U2 p. G& f1 G# S' d
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
* N. C6 ]" \& k- o3 u1 zfloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
2 ]! @8 W/ o" v* F0 Cfloat compute(); /*表达式结算器主函数*/- l* p3 \; N0 q: F+ q0 k' K( j
char *killzero(float result); /*去掉结果后面的0*/ $ W, B; w' b& {3 M2 m$ ~) s
" d6 ?: ], y4 ~8 A/ N5 M& f
int InitStack(Stack &S)& z3 e; |% [/ s2 r1 ]9 f# C) {9 d
{4 j+ B5 Q1 F5 y& h5 s: Y5 I+ U
    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
! ~/ ~; c# [$ i0 U. i    if(S.base==NULL)
- G9 f* P5 A+ o7 O$ F    {- ^9 z6 T  u& ~6 L9 a
        printf("动态分配内存失败!");$ Z4 Q: d/ C7 }& {1 I" q% |
        return -1;+ q" j( F& M- D
    }" Z; A  \/ [9 ]) z0 R' v/ y# X; u
    S.top=S.base;9 s7 A; ?! m* X
    S.size=STACK_SIZE;
  S+ }, z# n. ^% r4 x! G    return 0;, O% B) W0 g: o9 N# b* T( R
}
+ j1 j* T+ N* m- |& V  ~) b3 ?" }+ U4 Z# i
int DestroyStack(Stack &S)
# o% T- R$ H8 R# T. E/ w5 _+ F" O' q{
. T! t6 Z. ?& S8 E& d) t    free(S.base);
/ k+ h- x% s7 _- q    return 0;
" c% I1 H( A5 D& J8 O  I}
% Y9 j3 z/ d% Y9 w5 `: K! ~+ M$ _* c$ N) j
int ClearStack(Stack &S)% j% |2 h2 ?- Q0 I) l
{2 C, T, d7 J) u  s: q0 C3 H5 h
    S.top=S.base;9 v+ Q# _' v( C" s
    return 0;% x, W  {* T3 s  E" O9 S" f$ Z
}4 G9 N& \% f9 B( w! z- U

5 f4 Z" T, i- w% r# \" R' dint GetTop(Stack S,SNode &e)# _/ N" Y$ [6 c. v# j7 L+ `: J
{* p' J1 r0 F; j. Z" o8 `
    if(S.top==S.base)
6 [8 _1 e+ D$ r$ n6 w. Q) {7 c    {
6 A- U, P' [1 g6 E" t        printf("栈以为空!");
' h( O+ {* v" j. s) I        return -1;
/ _3 L1 t) `7 G" [; b0 O    }. c& ^# p5 o8 X# A
    e=*(S.top-1);$ l% \' g( {8 z$ o8 n6 J
    return 0;
& h  o/ U3 Y0 t6 z; [! ~: t}
$ {" B' o+ W; a' M# S) j: F, Q1 u- j: M' Q* D3 y4 B
int Push(Stack &S,SNode e)2 J2 P7 k3 E  x# l' h( B6 X
{
7 Y- ^3 T( c; P6 z    if(S.top-S.base>=S.size)5 I, r6 h/ f! I
    {
/ d: n% a% U" z/ i+ I  z. P$ b        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
; D$ w& T9 F5 L; g# A        if(S.base==NULL)
3 l* c; [4 ~/ ]- {- u! K: _9 ]        {! Z* U- h1 P/ h& k
            printf("动态分配内存失败!");9 @7 \- e3 M- j/ D5 v3 g
            return -1;
5 N  s, F7 n6 O        }
2 ?7 Q3 z; p% t/ |! P& z        S.top=S.base+S.size;
! [( J4 u/ X6 o2 L) Z        S.size+=APPEND_SIZE;  w% g; X2 j6 o
    }
# g* a  z" ~. Q8 O  `) G" v    *S.top=e;
' i/ i& K- C5 U; \2 s+ d1 U    S.top++;
+ F/ w( I6 H' |. x! w: M/ L- f: L- k0 y    return 0;  x- A( I3 Y6 J& n% ?  u
}& i9 N& V/ t$ b1 h- |9 O- B/ J+ T6 B
* V. Y: T9 V3 T, ^4 Z
int Pop(Stack &S,SNode &e)
1 b9 g7 h1 K, @. u- i2 ^8 V{! \" k: R1 M: c! c; m9 S' x% |( p- s
    if(S.top==S.base); f7 W8 }2 u8 Q& \% t) ~* K; Q" I
    {: r% Z; H5 K- u8 ^
        printf("栈为空!");
$ c6 c! I1 e. Y* C        return -1;
, W, ^8 y# O: |5 Y/ E3 V    }
/ N6 L/ {" }1 `& z+ n  |7 Z    e=*(S.top-1);
% J7 Q" L: o2 Y; v  O. i    S.top--;
+ _. d$ a- z. s  |9 u. x    return 0;
1 O+ B. Z7 f, D}
8 {9 [" P- h7 A# c7 z/ G6 S& U
! a# O" F7 Y) ^( Y6 {! `  Hchar get_precede(char s,char c)! v4 j& }$ s1 D+ H0 z2 @
{2 z% C4 S, s) y6 A/ x; I; N3 x; Z
    switch(s)! r8 D$ c; q2 H) N
    {
1 ]8 q. Z2 T) X: K6 G( c; _8 x- C        case '+':                 
8 Z/ h3 j1 C) B! X- \        case '-':1 ]  r# K+ v: ^; H9 _
             if(c=='+'||c=='-')( |5 a# c, x1 `' \5 w
                 return '>';$ M8 j- _4 j6 k1 |2 _( R
             else if(c=='*'||c=='/')
4 L) X9 V/ l% N$ Y                 return '<';
! d+ j: {% j" `, G" C- [6 k- P3 i             else if(c=='(')/ @4 J6 m: u! `8 i. u# _: y
                 return '<';
4 f0 C/ W3 J$ r3 C9 A5 y% F             else if(c==')')  d9 l  D% O) L, h. e+ a0 Y
                 return '>';, c9 G! i4 P7 {
             else $ U( V, R6 N# S* D# B8 v
                 return '>';4 J3 O: v, u0 B
        case '*':: k4 H" R- D" A' V
        case '/':, y0 ?3 n7 q& w
             if(c=='+'||c=='-')& [3 ^! J3 c3 w
                 return '>';
( E6 I$ x6 L) I- `             else if(c=='*'||c=='/')
, Z- b1 z- v+ \' G6 V5 b% Y                 return '>';4 O7 n# `7 ]" \# |" L: U9 v! d
             else if(c=='(')
8 Y1 U6 g  d" y6 h3 Q0 `$ i                 return '<';
# d* T. B$ _5 W" t- ^4 N/ Y- `             else if(c==')')
; [8 r3 H* j/ }/ I2 ^$ S7 S                 return '>';" r9 ^! E9 q( o. v2 i: \* y
             else5 J( L6 G8 @/ J% B4 W! o1 X
                 return '>';
/ m% ?: X9 f, ^% w& H) g5 ?  W! R        case '(':% l3 |/ s/ A' ~' b  [- R" d0 o# ]  Z
             if(c=='+'||c=='-')2 n. P' k7 s, Q5 H0 W1 u5 u
                 return '<';
0 O. {. n( L: e+ O5 O2 k6 w             else if(c=='*'||c=='/')
0 O) G- _% G, D( s4 @2 B+ z0 W7 A                 return '<';
0 B1 Y: V; E3 N             else if(c=='(')
, I! I  d; K( |* M                 return '<';$ {% d' R" _3 @& }; z* D8 R% W  U- h, A
             else if(c==')')' u& \  x: \" K
                 return '=';
+ M/ [7 x' {& E% s4 A- v& J             else
, j: H9 ]1 v. x1 n6 K% ?                 return 'E';
* w+ }* `: Z  E        case ')':
7 B% ~3 ]8 F  k% p" Z$ B9 d             if(c=='+'||c=='-')/ O( t% @1 ?& K. \: L
                 return '>';
. U$ C9 `4 o4 \( V. Y4 k/ O$ s             else if(c=='*'||c=='/')
' k5 q2 y( Q4 |                 return '>';
4 `# F& D0 W3 y3 Y8 f$ i5 M7 u/ Z             else if(c=='(')
& w/ T6 T2 I) F: Y/ g. U* `. L: g) |                 return 'E';: M8 L2 z0 c5 H) d& U, ?; S1 q1 s
             else if(c==')')
& L) Q. ^' H, D$ {! f; l                 return '>';
/ m5 d; m2 y2 @: N8 x             else8 W) C" E+ z# k: e+ j7 b
                 return '>';9 r$ y1 u2 ^1 W9 |: `/ c+ u
        case '#':
" f7 q! q: U! h5 W8 J: n" t             if(c=='+'||c=='-')2 P0 H0 t: f1 d  ^/ f) S
                 return '<';' {( y* t# X8 m+ z
             else if(c=='*'||c=='/')$ g- W; t) }) j! {' K5 S. M
                 return '<';# K$ \( j- U6 d; X
             else if(c=='(')
1 K( N6 @2 s/ R- d/ q2 `  L                 return '<';$ P6 l1 ~! I# k0 |: m5 z
             else if(c==')')" I6 H" m$ Y. l# }1 n9 S5 |
                 return 'E';
1 f. `# W# C9 a$ \( z2 Z  H3 N             else
, _# ?$ A6 G& B  |2 G                 return '=';
+ [4 |! @6 B/ v* w. B5 w        default:
0 j- R9 d" |! X             break;
" u1 e, p' N4 S0 ~    }
# O: e) Q" \5 v  D3 v    return 0;   
, t+ R+ v5 C3 Z; h' Q}
2 D/ s. M1 E& ?' U  w! x
: J; {" t- o5 W& {" Hint isOpr(char c)
; ]1 k$ S9 {" p) z: O{
( {. T8 c* Q" z5 w  S    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
% r8 D. Y7 l+ e. k2 ^' v( q        return 0;: K3 O1 [) c$ y6 J
    else 1 E6 ~7 ^, {# Q/ O5 A% f& A' R! @
        return 1;
0 ]4 T6 {7 E% P1 P7 d}
. X2 {+ b; r* }7 q* R' `! o6 @0 o2 n0 m
float operate(float x, char opr, float y)
2 |. V) c7 Q( ~{
' ~4 c! l& o( y  c! r1 A; N    float result;
; n& T! L* P$ R* S    switch (opr)3 }$ C& ^' }2 H$ O& O4 f! t& p
    {
+ K) Q8 O, I. c        case '+': : y2 j3 S! ?* B# ]' f% Y# I
             result = x + y;1 w  `8 L; T, o. J8 Z; G
             break;' \0 f( y; O8 E; k- x8 v% O; ?: D
        case '-':
2 K6 l. [2 u' v( {4 Q             result = x - y;5 x# J, P# V1 ~8 R# R2 b  e5 m
             break;3 E& o* z/ E6 Q& D7 k) s3 }7 F
        case '*': , b  k  Y/ O; C1 j9 E' ~$ F
             result = x * y;3 F7 z7 f5 {3 d8 }9 t8 F' K
             break;7 {2 V. h. i, Q; y& N( h
        case '/': & F  Q8 N" O' s+ Z
             if (y == 0), Y  U& F# k( M! A
             {
" R- C$ }$ ^+ a1 }! W                printf("Divided by zero!\n");$ R# X. C0 Z* q7 K# J
                return 0;
+ h, b- t- M& o7 f1 x3 X$ z             }/ H, ?/ _8 v0 e# g. R# }  V
             else$ T2 [6 c( X1 t1 }& T
             {& j6 J  U. m4 L; |& m
                 result = x / y;( f- o" L2 x6 _% j6 B
                 break;
+ C" _/ ~( E8 k, c, F5 s; \2 u' G             }
& e- E# p4 q0 ^, B- d  }- ?% n       default:
3 {7 Q) j8 f$ {1 X9 p/ \             printf("Bad Input.\n"); % ]) T2 n# R% \% m# J
             return 0;# \) p- p, |. `) y2 Y3 W1 x
    }! f; F; V/ ?: X7 F: o' Y1 f$ w
    return result;' m- R- M/ E( X2 d; A) l1 [( c0 T
}   
. {9 L9 G- a- y- P0 U1 A/ ?6 F/ B1 b. g9 ~5 C+ P; C5 d, x
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/7 j& a# Z# l% Q' m3 C9 W, r9 Y1 q: B
{6 _- J! O5 {* m/ R" X
    Stack optr,opnd;
/ b+ t' \1 m6 ~5 G: w7 ^/ q- A    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;$ p/ Y( Y3 r% a9 o7 |. _" Y3 o$ b, J  s
    char c;
' [! M. P! |) I, \6 ~2 e    char buf[16];
2 K; G% D; H4 v3 j/ g$ E' b    int i=0;
; n& l! t) }1 x# [    ; D. M* e/ T" {" u- T/ R
    InitStack(optr); /*用于寄存运算符*/2 o# y2 J, H3 i
    InitStack(opnd); /*用于寄存操作数和计算结果*/- z: e* z" g: _5 K/ v
    memset(buf,0,sizeof(buf));
. g9 s. M3 S9 B5 N   
6 L9 J) O5 i* a5 F0 l7 M    printf("Enter your expression:");
3 |+ T  ]# T  Y& V$ U        
: p; s0 {+ M; X# O, C% f% }7 s( `& G    opr_in.ch='#';# w6 \  S( p$ I# i: d6 U, ]" N
    Push(optr,opr_in); /*'#'入栈*/0 i8 m  t+ j6 C6 k9 |- s
    GetTop(optr,opr_top);
% ?5 u0 ~* U: K: f3 O0 ~    c=getchar();
* X. m- n9 V6 E) e6 s' Z- \' d    while(c!='='||opr_top.ch!='#')6 K" V- L+ H7 d: B5 A% d
    {8 R, l; O9 l8 R) v1 F
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/( a# }$ R3 T. q8 Z) B  b
        {/ O1 Z7 W8 M! T& |% E, n8 V( y' `
            buf=c;
! `3 F6 s) R9 Y) e0 ~            i++;2 K+ _. A: D" ?8 v3 J6 M
            c=getchar();6 h9 o( u$ @' ^8 C
        }$ ?$ m: C8 ^; A
        else /*是运算符*/* c1 |* U' z7 q+ X' `
        {
0 P7 o6 }# g3 `6 }! j$ `            buf='\0';$ |- ?1 Y! J+ e
            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/; H* Q# t. ~! z- b+ H
            {0 h3 b/ d4 {8 M
                 opn_in.data=(float)atof(buf);$ l$ B  T) Z; M$ Z9 h
                 Push(opnd,opn_in);
) ^/ A4 e: }+ `9 \# n% y                 printf("opnd入栈:[%f]\n",opn_in.data);
+ e6 o: w, u2 p9 _' y% ^                 i=0;, q5 ]3 p+ u$ T3 V7 Z
                 memset(buf,0,sizeof(buf));
( }7 D  v' P. F5 e            }
- @' \1 Y+ z: I! R. B            opr_in.ch=c;7 l  R. [* y4 A
            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/  Z0 N7 f% |. t( ?6 |; X3 h% L
            {
2 m: a" e6 p7 Z' F5 W2 p                case '<': /*优先级小于栈顶结点,则运算符入栈*/
, Z  B/ d* s+ T8 d' `5 @                     Push(optr,opr_in);) |" T! o" p0 p4 R
                     printf("optr入栈:[%c]\n",opr_in.ch);
9 h( K7 O6 c8 R. L0 J* y5 v                     c=getchar();: e( `- p& A, h6 Q  C4 f( T" n
                     break;
. D+ h2 p% `: w4 G% J/ j                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
. t' N7 A5 c7 u0 |, |. w                     Pop(optr,e);
$ d; K: R* @9 Q' b$ h                     printf("optr出栈:去掉括号\n");
1 x. d6 y* y1 ~% {6 J                     c=getchar();
& O) P" {: ]( \                     break;
6 A, a" d! J. b" }+ Z/ y1 f                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/  {. c8 X/ I4 _  B
                     Pop(optr,opr_t);
* P8 L: n. A2 b0 p( ]7 K0 C                     printf("optr出栈:[%c]\n",opr_t.ch);
! K3 O  C0 J) c7 |$ P* |1 w6 m                     if(Pop(opnd,b)<0)* I# U1 t( U/ v8 r: ?3 G
                     {
' r7 j$ M; `9 c! Y, Z                         printf("Bad Input!\n");8 ]! L" y2 I) p2 R2 }2 |% Z1 ]/ T# N8 z& m
                         fflush(stdin);  m$ A. C& M* D% y8 U4 m, B
                         return -1;  Q; F( q8 U- F7 u  w
                     }
9 Y3 _& u  q+ {6 x* @' x& H                     printf("opnd出栈:[%f]\n",b.data);
1 B6 ?( S" A' M+ Y/ x                     if(Pop(opnd,a)<0)2 B: s0 I0 D0 l4 W) R4 `
                     {4 o1 j  v3 p2 x! q9 y
                         printf("Bad Input!\n");
6 @" y% ~7 n) w6 M, I                         fflush(stdin);
8 J) e0 b* `$ G+ Y2 s                         return -1;
0 Z0 V; h6 w; n+ x, q                     }( o$ R/ n8 E9 ~8 n4 Z5 K
                     printf("opnd出栈:[%f]\n",a.data);* _1 |& y" q! X5 q% \- w  L9 }% y
                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
# U8 C6 f& [1 A. {                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
5 R; j1 ?1 W. A% r  O6 M2 [) C" G% I                     printf("结果入栈:[%f]\n",opn_tmp.data);* Q9 n: r0 W4 ?) }; q  S
                     break;$ c8 ?6 F/ J- c$ Y/ s) x& t6 U0 C
            }
; V$ I# w5 f* f$ l" z: l5 H        }
" [. Q2 R7 E3 r3 Y( o        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               
: X+ x# C4 t0 t! U9 c    }
4 z- y6 ]  {  B8 z' k8 `8 ?- Y. v    GetTop(opnd,opn_tmp);
8 R% s7 A0 e% }    DestroyStack(optr);
1 v; d) U% h+ m& p    DestroyStack(opnd);
+ u/ w5 R: P( H! t    return opn_tmp.data;( c  ^! h3 `1 p1 J
}
% t( Z* _. O% K& c
8 F* A: I8 p- Z0 g! Gchar *killzero(char *res,float result)- b- \4 [  h* }( L
{
0 r, X/ a0 d& n: Z5 K- f    int i;' e4 [- ?3 e- ?% f1 Z

5 G) F. k) @$ |+ q8 w- t7 Y! |! ~    sprintf(res,"%f",result);. T( I8 c. N2 n6 n5 k3 c
    i=(int)strlen(res)-1;+ B# S" X  o$ ^: m0 ^  r
    while(i&&res=='0')1 d5 v* D' z/ r) f, l
    {/ L1 A, R) G8 I+ w8 N4 p
        res='\0';
1 i# e% q+ f4 N2 |  x  L, m! {        i--;
1 j6 E& ~! U; b    }9 `' S" W+ ~$ c$ v2 H% J
    if(res=='.')
, b+ e3 w! o! k% g4 m6 m6 K        res='\0';: E7 e8 P- H( z% H( ~/ y+ G" U* Y( c
    return res;
$ Q2 T1 y" Q% b' j/ K% i}/ ^3 {. K- ?' r2 Z5 Z# H
7 d% u9 V* l$ l$ ?. k2 w6 G
int main()
$ G: s0 w  @- u( w+ V{
0 M' ?$ E$ l& z' K, |    char ch;% U/ h& e4 P$ Y. U
    char res[64];
5 m) \! x( D( ~" T, W    float result;
: a4 L8 R+ B  v8 k' k- N( a" P& {( g    while(1)  F; t% H. J% M% z/ J6 v% H4 E. B) `
    {
' @% i+ [% a+ a. u- @+ s        result=compute();7 ?) Y8 J, u; u: n, t) [2 F
        printf("\nThe result is:%s\n",killzero(res,result));- N. u9 B% q1 |3 [
        printf("Do you want to continue(y/n)?:") ;
7 `/ I" N+ y* p( x7 p        ch=getch();  E/ J1 E; c( h; Q3 H8 R0 R0 b
        putchar(ch);+ Z' F2 t* g% b& l  G
        if(ch=='n'||ch=='N')
0 z+ {  ]" z: S, i, k0 k5 e, @            break;
0 g: I& z7 r8 @5 F, T        else
: X+ Y0 S) J; Z. P# z# [" @: [  |            system("cls");" ]' M" C- v! T5 X& J4 m
    }$ q6 f0 {% y% r! |
    return 0;9 C8 w; f" _' I+ v. }' J
}
3 s, n' R" @0 R  B/ h
, X; w% ]/ O3 ^# F, G
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表
【捌玖网络】已经运行: