返回列表 发帖

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
, z7 f8 a. a1 X1 i; Y/ W( c程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
# D5 }9 \: {# \/**************表达式计算器************/
3 x4 Y1 Y; `& F2 i! P#include <stdio.h>
9 O  ^6 {; J% K# U: c$ M#include <stdlib.h>
) @  k5 l! @. ?' R# C#include <string.h>4 Q( `$ s9 \+ ?
#include <conio.h>
# e, |: V9 j2 _+ r3 @4 G5 Q5 s#include <malloc.h>' G* ~- r! x" u
  i7 @7 u8 s4 G; ^" O* r" W
#define STACK_SIZE 100
4 i8 O" R* [7 a$ y) V#define APPEND_SIZE 10
; }. J4 A. ?. |# {5 |
9 c- X3 O8 N% R' o0 V4 bstruct SNode{  {* t& O: R0 ?$ N: ^9 U2 c. \0 u
    float data; /*存放操作数或者计算结果*/- c% _! l, }8 Y! g* P
    char ch; /*存放运算符*/
3 a, k1 @" g0 X, L};
$ S( b8 y3 A# l; e
1 o+ S  R8 A" Dstruct Stack{
2 e: a4 l$ s+ R* a; ]1 v    SNode *top;
" X7 w0 q' o7 D3 U6 B! V- H9 Y    SNode *base;
' p4 p5 ?& U" q% s. D7 G1 D    int size;
- F/ a8 o- t& m6 }};- M; g& U" m4 i) w

, N: Q( B# m4 d/*栈操作函数*/
6 Y4 H7 F6 E4 ~. y  fint InitStack(Stack &S); /*创建栈*/
3 {& \$ F9 X/ a/ [2 [% L5 vint DestroyStack(Stack &S); /*销毁栈*/8 y% G9 a! G0 |
int ClearStack(Stack &S); /*清空栈*/' [5 z8 K6 j0 B0 x9 F
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
2 h/ @. I4 t6 I# y' G- iint Push(Stack &S,SNode e); /*将结点e压入栈*// p! ?6 Q  t, |
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
4 ^- _3 ~) l  o! N$ z" i; I, V. {( L. M
/*表达式计算器相关函数*// s' q& H1 {( g9 k
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
/ L' U6 S+ F7 hint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
" \0 n4 G* J  Ffloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/$ ^# l! N3 V) j- ^& f) V
float compute(); /*表达式结算器主函数*/
% S8 m; Y4 d) x: S3 J) Hchar *killzero(float result); /*去掉结果后面的0*/
' A& M- ^/ H. v$ ?$ `! J) Q  i9 p. X! ~$ Y1 q# o: s, Z
int InitStack(Stack &S)
5 Z# `' ^3 }+ N{7 j3 I3 t# K# l) J/ @4 {# n. t
    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
0 w% r- B# m7 L2 B7 u3 P% f    if(S.base==NULL)
8 Z! A2 M/ t$ N    {
- m7 U  k  ]1 l& D3 Y/ ?- Z        printf("动态分配内存失败!");
6 b, C1 P7 Z2 `/ w* y, t$ c3 C        return -1;
  P7 c. G! k0 r+ e3 F; M4 _3 `    }7 Q( ?3 u+ \- y+ k# Y* S. v2 ?# A
    S.top=S.base;- k* d% z* ^: G# N$ U
    S.size=STACK_SIZE;- @& h: h, d" F- A$ W
    return 0;- w2 {& s# h0 N) U
}4 ?* U" ^7 {) {$ Y, d

& N% o9 v  e0 v' g' o& V, wint DestroyStack(Stack &S)
, q( D/ Q, c: Q* i9 T9 c$ G{
. s4 U: Q$ w2 A$ y8 v: j; w    free(S.base);
0 g! L1 u& e& d9 k* e. A    return 0;
4 H' ?2 t$ p9 Y0 n  c}
% i7 e& q* M! G! P7 @' X8 y, k$ x5 Z! B
int ClearStack(Stack &S)
2 |- a9 v. M+ s4 b{
# G! P: X. g' |    S.top=S.base;
% Y+ g% b; n( A0 a$ S2 _2 y. s6 L    return 0;. b; y$ S" O+ w3 o
}
  r* j/ T, O% A5 f1 E+ U/ @+ ^. H2 h+ A* \- ^" o5 h4 h
int GetTop(Stack S,SNode &e)
% v, o6 q/ e' G$ j+ I- O0 Q{
8 h9 T* b5 ]( J3 b5 u9 u    if(S.top==S.base)
; _& D0 F: w* D9 D0 d+ G& c" z4 ]    {
" w% O" w# G5 I# A5 m        printf("栈以为空!");/ U2 B4 {" U1 V) a" n
        return -1;
$ G) w* I6 u4 L9 i    }+ y; ^* W8 c8 N9 v$ J6 }
    e=*(S.top-1);* o" U7 O' i# F7 g2 ~
    return 0;
# \% A) `" L  v8 g% q}
1 {1 V( {" z9 l) s8 }% U# K- h0 l$ \
int Push(Stack &S,SNode e)
3 K/ _& Y7 ?6 b' w$ e{
8 ]2 a$ M8 m4 @" \/ E! W) x    if(S.top-S.base>=S.size): H4 q$ d. _1 k: i6 q: F$ @
    {
) o4 C% ]: v3 u  _/ ]: q$ |        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
9 }& N; _: W; H7 g0 ]& e9 t, Y        if(S.base==NULL)
& p- e& t$ [$ b, F. \        {
7 \$ u, N# l- \* {4 F. h            printf("动态分配内存失败!");# l# g  j8 Z3 |$ H+ Z" u- x
            return -1;6 ]7 E8 {+ ?& E/ q2 U+ x1 g. p
        }
7 V2 q1 v" x2 R( a; e        S.top=S.base+S.size;
: {" ~* r  m* U        S.size+=APPEND_SIZE;
# Z! ~; C, L1 W( g0 Y* E) Y  W    }
* G8 l" ]0 Z$ C, k" V+ O- g    *S.top=e;
0 U; z2 {, t2 f" G# P! q, y    S.top++;
8 A: |6 U  z" q. B5 @( D6 f    return 0;
) \! v- S& _7 b2 i0 N}3 g* H7 X. o# l' H/ p) i

/ z/ |! ^8 r7 u  Y: rint Pop(Stack &S,SNode &e)
1 E* p; `. T$ D7 `& i{5 H, d, F5 w6 ]6 B3 ^5 F
    if(S.top==S.base)
; x- F$ }3 T) n$ r: V' f2 ]( y  t    {
  J% D! K# q8 ?        printf("栈为空!");
9 `- V# c% u" H$ C  s7 x        return -1;
  H& z4 L; b5 ?) t9 k( @9 O    }' q5 E& K5 x$ r; \
    e=*(S.top-1);5 ]; C, z* ^. g# ?# c
    S.top--;
: E: Q' x  R( m( ?    return 0;
; ]! X/ u9 e5 z' w' U8 T* N' g}
% c: U" l: H( j, w$ |& ]
, t# x+ E; _# {6 m# x* f& Tchar get_precede(char s,char c)
1 b) A: g5 Q& N- z{" s0 e& [6 C! m, h0 D  p9 Z; k, @
    switch(s)8 h* o: f( `. Q4 F- ^% U
    {+ d9 @$ c5 Y7 H( L
        case '+':                 / M2 m  D! G, d) _/ h5 W5 E0 n
        case '-':
- X% c/ ]# d; g9 |. }" f             if(c=='+'||c=='-')
# G) H0 F2 f+ Q6 r; F                 return '>';
6 Q4 s7 p/ Q4 [5 @) c4 M             else if(c=='*'||c=='/')4 `% v) s4 {/ D) A, X/ d1 G. S
                 return '<';+ {* l7 w, ^! L* S5 A% t4 d" C
             else if(c=='(')" `/ a: B9 V  i2 b% M
                 return '<';
! }( `, [7 ]! E+ z* A+ g- s4 e, l             else if(c==')')
) w/ V9 z9 T3 Y) B                 return '>';  Q) y  H7 c+ Z9 i4 ~
             else
  `. {, B0 E) I3 @/ i                 return '>';
7 S; E; Y, H% R1 Q+ P        case '*':
* ]; R: \- B  d/ z; N3 V        case '/':
# h$ Y" h9 P( k4 ^6 \# E8 j' V+ k             if(c=='+'||c=='-'), r0 x6 ], U' b" R6 ?, O& ]0 d
                 return '>';
/ W, ?; {5 D7 p' U             else if(c=='*'||c=='/')
# }! R$ H6 b1 H: r$ f                 return '>';, X+ z; J- Z: }) S" |, H8 G
             else if(c=='(')2 F5 E) S( f3 _. i' Q. t6 Z
                 return '<';9 h% B7 ^4 f% }8 {4 ~7 V/ Y
             else if(c==')')+ Z; Z, z/ D. P- f
                 return '>';1 u/ |! h$ ]7 q
             else/ j& E  W: E1 m1 `6 N! O0 d
                 return '>';
& f" L- V# K$ |# ~! o( K        case '(':! g" e8 [3 v1 J$ w6 P0 C3 y
             if(c=='+'||c=='-')
5 X$ `& ~4 H* J' F5 }( d* p                 return '<';
$ A$ i  J' ^; R" a/ v4 w, B! U' w             else if(c=='*'||c=='/')5 R# Z/ A1 r! A: l
                 return '<';
' F  K; K3 Z- p1 E1 p4 l: L             else if(c=='(')
/ i1 w3 }* U# A& J                 return '<';
& F4 `9 ?- y8 b  X             else if(c==')')% h2 v% K: R" [( J0 S/ M$ u, P6 I
                 return '=';, v- r3 D" l$ J
             else
; ~6 O; _) u8 I6 |4 y0 r                 return 'E';, R5 F9 a* f; r
        case ')':4 k% R, y4 V! @" [# j' Z
             if(c=='+'||c=='-')
3 L% L% X- p3 J+ Y% G                 return '>';8 Z# o! d1 t5 h5 b5 [" z
             else if(c=='*'||c=='/')5 D' m1 x# O9 b$ Y* R
                 return '>';
" N' a2 Y0 t3 F- L) S6 K. U             else if(c=='(')
3 Z! q& a  z6 a7 o& C! g" y/ D                 return 'E';) i. @" _0 w" n8 [" ~
             else if(c==')')3 g3 O% y6 F  O6 R" n) d4 x$ }9 l4 ]
                 return '>';* R; x3 g, v: _" q- |. [; Q
             else
' {; u  w1 T& _5 s; T                 return '>';
" m, O* A4 G" B4 k        case '#':
& m" F1 l& C3 ?) G             if(c=='+'||c=='-')
% p- D" F/ _* K: ^) T                 return '<';$ \1 X/ \* q- ?" o
             else if(c=='*'||c=='/')
. j6 w/ a5 @- ^2 U% S7 m1 Y                 return '<';
- {" B2 b; [5 `$ s& X- U7 `/ I  l             else if(c=='(')3 Z9 p5 f# q8 ^+ v
                 return '<';
7 ~& A$ D" K7 n. P$ U9 t  ?/ Z             else if(c==')')
4 D* x0 ], C! y6 q! G                 return 'E';4 h0 V* I9 Z! _- E. V
             else
  S4 K5 G6 R& @$ a' X7 O4 w                 return '=';
6 t9 l$ q9 O# C( ]/ T' c% t8 V8 Z        default:
1 {8 K+ w# w; \# A1 @% r             break;
( E! L8 W8 F% X( ^7 m2 q    }
" X: f# j7 \8 i1 V; L8 w" }    return 0;   
% s4 }' O6 k4 |}1 D% O+ J* x' y
$ U2 q: W+ |0 q8 }3 N/ W
int isOpr(char c)1 [$ m6 d+ F, w  M# m6 a1 C+ R
{
7 [3 C, G9 Z; k% g/ q8 c* F$ O- y( c    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='='), H+ s/ B/ C! F9 s' R( _
        return 0;
% N( H! S, ~1 d) R    else " V! U/ R$ T! i. g) T, Z4 ^
        return 1;4 J3 L" e! N- H
}: Q* f4 w% U' G. H, t7 F
! M9 @' D' U4 V8 K
float operate(float x, char opr, float y)
! Z& i. L8 A0 X/ q- C! G2 M% R- p0 N+ H{
1 W- F/ Y  W0 r# b/ G) P    float result;
. ~& R4 t) {9 V7 p' c    switch (opr)/ \0 q6 U7 u8 _" w8 L
    {8 a7 F. s* v) k
        case '+':
% y" O/ I. X( b- x8 @3 B             result = x + y;: s$ Q9 |  W; Z
             break;
4 \& j- i" K7 D! E        case '-':
7 U& m. F5 Z& m$ K             result = x - y;* S1 R( }. d; h4 p
             break;/ p0 l7 i6 K. N# A8 R- F4 c/ P
        case '*': " H  v% }' m3 j4 n# L4 Z
             result = x * y;" p1 G5 Z$ f9 n1 `" Q6 _* R  B
             break;
- u% u6 x1 Y0 P6 v        case '/':   z; S/ z/ |/ a& s7 ^0 V
             if (y == 0)
& V2 q6 d3 T$ g5 R( u             {
2 b4 q3 h) C* X7 N                printf("Divided by zero!\n");
4 t$ S& ?* o4 W- ?; f' O                return 0;
* R+ e, l- G1 _& _* e* H' W             }8 t! Z6 K$ I7 B3 \/ I& }
             else6 H" n$ ~( b) ]* k9 t: A, J: z
             {$ x4 a+ n9 `4 M1 L/ K( s0 C4 @* l
                 result = x / y;
- a# r* h+ H' I, J) C# z% T                 break;# G+ t5 }$ J, z. E% h# H8 `7 l, R
             }
, m# U6 l* u& N, ]5 y       default: 5 G1 k+ \: P& A8 O4 n, t
             printf("Bad Input.\n");
0 S/ R) U" G; }  X9 e( E. ]             return 0;
8 L+ F# x2 a1 N& \# {1 g) [    }0 K; a1 @8 W! R5 y' N% ?5 p  z
    return result;$ K* \2 F( p" @( K6 U8 [4 f! |3 W
}   
4 D$ j$ F4 ?+ D  n$ Q2 F8 k9 B- H; C* @6 M% F% P% I
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/: o$ W% m! h9 _
{. q2 J  p/ W3 d) u
    Stack optr,opnd;
, C+ ?' f: w5 J$ W$ `' b* S    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
! J; R& f2 i& ^    char c;
9 J$ z8 E  [; ^$ l7 Q% V0 p    char buf[16];! _' X1 a/ C- r- w! M2 g$ o* W
    int i=0;$ K0 ^1 t" v4 `1 f4 [
   
/ S& v" i) l3 S1 y1 ?- M* E. A/ h& E    InitStack(optr); /*用于寄存运算符*/
0 o; J2 D! z6 t$ U, V* N% p! y; k    InitStack(opnd); /*用于寄存操作数和计算结果*/
& q8 S: [+ m* e7 E. C5 s    memset(buf,0,sizeof(buf));
3 `) b* P/ q1 v+ X5 G    % o6 X( B1 B- t0 P+ v" l
    printf("Enter your expression:");
  e& _$ E2 ?& M4 {        
7 W6 X  B3 O  O# ]' }2 D    opr_in.ch='#';
' @( B# G1 b! a0 J    Push(optr,opr_in); /*'#'入栈*/. w6 r/ [3 y, l0 a) [) r- E( s! y
    GetTop(optr,opr_top);
5 R& G8 y0 c  o    c=getchar();  a7 g1 W. e( o' g1 \. A  I
    while(c!='='||opr_top.ch!='#')
6 E8 b; {* B2 J, h. [* t    {% q* X. B$ k! h2 @7 [* ?$ {, j2 {% |
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
  Z; _" ^3 Q: X        {
1 {# b8 Z$ l8 b            buf=c;% P$ T7 R0 f' v9 b3 g. B! h
            i++;
* Z1 c+ c8 m/ h1 A( b            c=getchar();2 k+ X% L. ^( F  p! Y- c
        }
( K' @6 I# u8 [7 Z! d        else /*是运算符*/% E9 G- f: i4 `8 @
        {' M9 z. Q0 G" |- P' d
            buf='\0';, O5 K* h2 u# M; Q" E
            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/- r7 N0 s3 g3 l* J  X
            {# g6 m" l$ d* t) l8 p0 o
                 opn_in.data=(float)atof(buf);+ \% J# A* m: P
                 Push(opnd,opn_in);# f( `, ]7 f( q! _! @) |; l3 R" S
                 printf("opnd入栈:[%f]\n",opn_in.data);- K: x3 K* W" N3 F
                 i=0;
1 h! C0 H5 q+ O5 T4 l8 Q) J                 memset(buf,0,sizeof(buf));5 G3 J* H9 |! _0 S- r- q/ B, {. B
            }( |4 l7 ^, \; m) F8 Q
            opr_in.ch=c;, f1 v( A8 T* t  j7 @7 u
            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/; t  _2 @* a# k' H3 p( ?
            {! n2 i7 N! Q* L4 i: r8 g8 a
                case '<': /*优先级小于栈顶结点,则运算符入栈*/
; G+ s9 Q1 m3 E- Y# g                     Push(optr,opr_in);0 w' I9 ?( L+ t
                     printf("optr入栈:[%c]\n",opr_in.ch);
% m5 r. h( C7 N" r5 L                     c=getchar();5 x7 z0 g% a5 J& j" k
                     break;
8 y$ ^, ^) M* m7 }                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/( T6 x: e7 a- a& k* l6 Y
                     Pop(optr,e);
+ B+ D' z6 n1 P( P9 o# |/ j                     printf("optr出栈:去掉括号\n");
! @3 r: X, O$ s8 l+ o                     c=getchar();
: _% F8 V) y  F5 W                     break;7 i6 ?9 |4 `$ P, G
                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
$ e* h9 o1 _/ E: A3 i* J9 Q                     Pop(optr,opr_t);
; Y( ~8 c, F  k0 H                     printf("optr出栈:[%c]\n",opr_t.ch);, `! e/ I. x, H' p$ O! j% I
                     if(Pop(opnd,b)<0)
! L% p2 w2 ^# Y! D4 |                     {7 x* P2 n" X5 f4 }" j
                         printf("Bad Input!\n");
0 g/ U, I; t0 z  s# ~, _2 r                         fflush(stdin);
8 I$ R- j5 R4 F3 r( }3 j! [                         return -1;
. d1 w, B+ F, F2 q' h, N; h) m- `+ U                     }
) _( H/ \; s2 S0 S/ `2 c) v0 v                     printf("opnd出栈:[%f]\n",b.data);3 K# T+ U: T& \8 Y& \
                     if(Pop(opnd,a)<0)% j3 i; H* q3 n7 Y* Q
                     {
7 E# S9 ?: {3 ]$ ^- A5 H4 p/ p                         printf("Bad Input!\n");" S# d* a" v- ]' Q& W7 q9 b
                         fflush(stdin);
0 F0 C# C6 C  b0 Y: Z4 z                         return -1;; _$ H+ ^/ o; R* U( [, Z% [7 o
                     }6 f- P9 T3 ^6 K7 E" z( d
                     printf("opnd出栈:[%f]\n",a.data);8 {+ {+ g! h& A
                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
6 T7 r0 K' \. ?2 @& r                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/; G4 T7 U  c6 _* I
                     printf("结果入栈:[%f]\n",opn_tmp.data);. g9 o5 t  ~* v4 ?; v
                     break;$ f4 _  I0 N) Y2 ^& d* ]
            }  P* V* f7 l3 h9 L7 ?1 p
        }- |$ G3 o& [4 s: `5 j. C- e
        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               
+ I$ H5 Q- Q+ o$ B    }( ^# T& \/ `! x' S  }8 G6 {9 n* Z
    GetTop(opnd,opn_tmp);4 D5 i5 w! o( x) X  v% v4 o& v
    DestroyStack(optr);: Y- g" C9 F' Y) ^/ G
    DestroyStack(opnd);
& \0 B- n) m; U    return opn_tmp.data;+ ~! N) p* j2 K/ d" M
}
& I$ m0 N+ \: s; B: S1 r+ o5 z( G2 b% D2 r7 ~! E) e4 u- H2 d
char *killzero(char *res,float result), y) Y" p/ M3 Y5 _* i. |0 x
{! p0 |# f  B2 B" ^
    int i;
: ~6 Z5 x7 J, v$ F* L7 R7 g$ F( @/ Y( a
    sprintf(res,"%f",result);
# x) O' _% z0 M5 j& {    i=(int)strlen(res)-1;
# [& Z! X3 E& S  o5 M# {/ x    while(i&&res=='0')! u( z0 t" }2 o0 C1 A, c$ X
    {8 U8 P% F# ?& v' ^
        res='\0';
8 v3 y- N! N8 j* E. q, a        i--;
' [7 o9 z8 T" c% g    }2 u- m4 P* f- O1 U" b
    if(res=='.')+ B( A( i2 \9 j# f
        res='\0';! f  k& L1 h2 p/ Z) N/ P
    return res;' |: m& o  G% u! ?7 l5 d& q& T
}. p: Q% q$ @! P' ]7 P

7 s! Z/ E- V% |* s( J8 Pint main()
+ C" \5 p# X; f: R! L8 g- d{
; }$ U, ?6 F+ @* y  q. Z0 C; h    char ch;
2 B8 ]/ d; P# z$ a8 w$ b  k: v; v    char res[64];7 @3 n( B: Z9 u: E6 r3 V
    float result;
$ W( g0 c3 y7 t" D# e    while(1)4 _5 L. X( b. X: [& o7 C2 u
    {
( }9 M4 ^" w* F4 o! C        result=compute();/ R' w8 w; {2 U0 t$ b
        printf("\nThe result is:%s\n",killzero(res,result));
6 D; a  _9 Q6 W. a        printf("Do you want to continue(y/n)?:") ;
) k  f' _3 ?8 n  }        ch=getch();/ [# F  H- K" _. e
        putchar(ch);
2 ]& m( C- F* L/ V        if(ch=='n'||ch=='N')
6 [: p; h" J+ C( H. Y2 U* t            break;
( K1 J) E+ }  g6 L        else
$ j# F0 B$ A4 l& E2 \6 ?) J            system("cls");
  j* P# B. T# q/ l# R  a0 t    }
6 W/ P1 m- J3 x4 i9 k6 R& v0 K. I    return 0;
* z# u$ Q) S9 W}
4 ^$ c% w5 b6 U8 X+ X
0 A  D$ ]- P, m" F+ H8 N4 C
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

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