返回列表 发帖

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
' X$ J; E" y$ V! Y& }! x8 F程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=  w1 a9 i2 U; q3 m9 U; N
/**************表达式计算器************/
* u  w$ j! n3 e" R3 d6 F& F#include <stdio.h>% s' W/ Y& }& {& n' y% B  o$ H
#include <stdlib.h>
6 o' E1 c- s) `+ e! a#include <string.h>- v$ D+ w. c9 d4 {. j- X
#include <conio.h>
6 C( `1 G% [- |  b4 `# r#include <malloc.h>) o" w% A& t0 _1 A# C0 Q4 G
' ~- D( E$ a; ^
#define STACK_SIZE 1004 j% y2 J5 \/ t6 Y2 J
#define APPEND_SIZE 106 @6 \5 J+ l5 t$ w& d( u! w
, T6 R0 V- T4 j; V2 O" s
struct SNode{
$ j, V. h+ V9 C0 R' M' r, m    float data; /*存放操作数或者计算结果*/
% J5 O9 t0 k) ?$ G    char ch; /*存放运算符*/
1 u5 t: t; [$ a& Z+ T: |};5 @* }9 Z6 c) }2 y+ b$ v6 m3 y" N1 ^

% U2 Y- I! Y4 l& r' o0 w! o+ Mstruct Stack{; Z3 L# Z& g: @( G# x5 o
    SNode *top;0 y4 p- d! @0 [3 l
    SNode *base;
/ Y- x0 J& h' p/ u    int size;9 x$ h2 ?. n1 b% C4 t6 [3 c8 o! w
};
' C: `2 U4 v1 j/ T; E' E; S+ E  X
/*栈操作函数*/
3 v$ Q2 n3 `* ~8 P7 |; c* Wint InitStack(Stack &S); /*创建栈*/  r- g% h0 S; o0 C% W9 _/ I
int DestroyStack(Stack &S); /*销毁栈*/
( G3 z9 g& l$ r' c6 ]( `int ClearStack(Stack &S); /*清空栈*/0 W5 A3 Q8 X% \
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/  D* x3 r8 A* d' r5 j4 K
int Push(Stack &S,SNode e); /*将结点e压入栈*/
3 S: l8 b2 ~2 l6 h; x' R# t' Dint Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/4 N, g" z- O% c3 ]% M. Y

! H# K# {: j  U; `/*表达式计算器相关函数*/
4 e8 m# F* Y8 o# `) Cchar get_precede(char s,char c); /*判断运算符s和c的优先级*/
3 w$ }9 C9 U4 {5 X  w9 Bint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
; j1 ]4 H2 b; s6 A8 W3 x% w) f! M+ Dfloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
9 q; V0 t. z" q. A$ P, Gfloat compute(); /*表达式结算器主函数*/
! T* K4 p7 p) {: q5 @char *killzero(float result); /*去掉结果后面的0*/
5 w; o: h9 a- c7 @$ i4 M" d9 j( D  t3 w, _# J6 G# q# _
int InitStack(Stack &S); T7 f/ D( W$ i+ y/ Q
{6 m" L# G# I" I7 U% a
    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));: @" X# M: ]& P7 `
    if(S.base==NULL)
  X8 g) G: D/ U5 ?7 s# l' Z    {
& \- Z2 H# j% a: o! e! F1 ]4 b: i        printf("动态分配内存失败!");
9 R, E6 g, A1 H# Q        return -1;: f+ w$ t2 l- L5 w% E/ }1 B
    }
& Q! E+ a/ {3 e* u* E, c$ D9 J. Z    S.top=S.base;1 R. s6 f8 z. [4 s: C  [
    S.size=STACK_SIZE;" L% x$ X& R4 ]4 ^( Z% d; y
    return 0;
* h# ^1 J  w' h1 B}2 k* T& E9 m; ]$ O: y
1 E- `) {7 ~3 m1 I
int DestroyStack(Stack &S)
3 ^( x* l( }% v7 S{
8 [/ {. |* t2 q- i3 b% Q3 {! `3 T    free(S.base);4 @: Q( e+ J+ @- n9 q
    return 0;
; T8 I4 Y% k7 K}
: w  i" E3 D9 z* U/ m& {, ]
! A: \2 ?9 a* i0 ]# s# u" j* tint ClearStack(Stack &S)
& x3 \' s! g; P7 p( y  J{2 O3 |  G. f4 C$ ~$ ^1 u
    S.top=S.base;
. p# D. _8 t" m. S' }: a! {2 X8 p    return 0;
, x, q! C+ o7 @% x2 [}  R) T3 y# H/ L+ @: H  m/ R

, q: S; ]; B$ v/ D2 }& _- \0 o& ^int GetTop(Stack S,SNode &e)  _$ Q2 o" ?# a% [6 _
{4 M. v& C: B3 f! G( V- }2 P
    if(S.top==S.base)
; T$ P7 T  V! A3 `4 k    {! R# [2 H( |/ b3 e. R! P3 c' E
        printf("栈以为空!");' I" U8 S4 o* r2 m
        return -1;* s1 A; _+ P3 Y) t6 @' a
    }
! C- r' p$ P- i2 w    e=*(S.top-1);) N! p4 ]# K  p0 X9 n
    return 0;2 w7 Q6 S, f% n; T# e, ]
}
* J7 s) b0 S9 Q; `, J/ G
7 R  D" n* s* y# ?0 m. Yint Push(Stack &S,SNode e)" e! @) e# f4 |& \0 e' |2 [
{
& Y3 t, o$ t8 T6 ?/ m4 C6 E    if(S.top-S.base>=S.size). a; X- y: [% G/ G$ o5 X
    {
& j) |1 Y' N: t. {& d        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
* Q" C$ {0 \/ u# L/ b; @        if(S.base==NULL)$ G5 \. p* U2 r6 q
        {8 y8 N9 p) z& X1 n1 f% v: M
            printf("动态分配内存失败!");
) T, M- ]4 A& F+ ]! ]& h  l            return -1;
8 f6 J8 K% s9 A) _1 S. z        }( A) r& \2 [) |* w
        S.top=S.base+S.size;
2 W" K8 s- v+ R' l  r. K        S.size+=APPEND_SIZE;
5 R6 [+ f" O! m    }
8 ^! ^# }1 p6 e6 ?1 c# w1 m/ s    *S.top=e;: p" T( J5 R2 J/ o3 o2 A  r. R
    S.top++;
, x9 C5 f' M9 e8 b! }3 X    return 0;
2 [5 p& t, E7 J9 _  w- f}
& F2 K$ G6 b; v/ W! y2 P. e. a4 O5 f, a0 X
int Pop(Stack &S,SNode &e)
$ z& d7 l8 q7 A8 x0 }$ |  \{5 w4 L4 m1 \- }3 L% t
    if(S.top==S.base)" q* R+ e# o' h! s# V) I! @
    {6 u  J4 `8 \5 p4 {  ~0 n: ^8 Q- L
        printf("栈为空!");8 r1 a2 |/ Z2 J# ~" O4 S
        return -1;' G, O& I) }& A; @! B
    }$ g  }) `9 Y! o2 @- v7 P
    e=*(S.top-1);
$ S  q! ]0 ?$ E( j- W    S.top--;
. p( z8 `# w) Q: x( c) C    return 0;
- R! O7 ~5 F7 m0 `}
8 D. T. H3 T: o" O/ K3 F8 b, q* W  W* d9 U6 p
char get_precede(char s,char c)$ g5 v  [4 y% M: ]4 a" `1 b5 _+ O
{
9 v. n- o. l8 ?# P2 j9 a* R7 _3 R7 l) x; ~    switch(s)
: @5 x( I2 t9 G" U- m! ]    {) ^3 W) a. Z" s
        case '+':                 ) v9 v8 v! e7 x7 @
        case '-':4 \! _' T$ |& ^  D# B: o; `% g) i
             if(c=='+'||c=='-')+ {' d# L  G- K* w
                 return '>';+ O$ z  V: }/ q) _) Y. r- x8 N
             else if(c=='*'||c=='/')2 g7 A2 E. |: {$ u3 m
                 return '<';+ h% Z  n3 F7 n; x5 ]
             else if(c=='(')
, e9 D$ k7 T/ _+ s                 return '<';
6 ^$ J* }# D4 T* o0 ^             else if(c==')')% a4 `$ O7 ]) s6 Y9 l* x& h9 g3 }
                 return '>';% b1 A- O( U6 O: {
             else ( ?- M. W4 d: a, e. P! w
                 return '>';% s2 m$ M/ Z% `* w- n# f; H
        case '*':# O, e% g/ \. m& y
        case '/':
9 @, K2 a+ C: O" Y* E7 ?             if(c=='+'||c=='-')* Z( |- f9 D: P& |. w2 T+ }9 Z
                 return '>';* c, C: `% ?5 p0 E- R; v: T
             else if(c=='*'||c=='/')
( O; ~7 l$ g- t( V+ @+ K0 }                 return '>';
+ ^2 C& j) j7 a             else if(c=='(')* g% D$ j' F; E8 ^' Q' ?$ o
                 return '<';
: d' B: t, j' h4 m& T7 ?3 L             else if(c==')')+ d+ `' L) l1 g/ n
                 return '>';
: y3 @( h- Q8 y" K! C: |             else3 @( T3 b+ ]; ]* Z* [- o$ B
                 return '>';
$ P! `2 U1 p3 L( K        case '(':
( N$ Z) D8 M6 f* t$ l* s             if(c=='+'||c=='-')8 D2 L9 x1 _1 E, ?
                 return '<';
- e0 ~2 P$ Q3 J% u2 a2 N7 S! g5 T+ |- B             else if(c=='*'||c=='/')
8 X( ?( \9 q2 \. `                 return '<';/ Y* N( z0 g/ x7 B. {# }
             else if(c=='(')/ l8 N# C7 k9 b: Q! ~5 C
                 return '<';+ u$ [2 a3 l. p& f, [1 k  l
             else if(c==')')
1 e4 l# x' \* d8 Y& c$ d                 return '=';
5 P& f& U& l& ^% V  D; l4 e             else, P& C9 J+ s3 E# S, x
                 return 'E';
& N2 w7 d# F8 P6 K9 N! @9 F- f        case ')':
% c+ O0 Q  _% E1 k             if(c=='+'||c=='-')! x6 s2 \2 c+ [! U( E
                 return '>';
9 U5 l) ]6 x  ?, S; B- y5 N( M             else if(c=='*'||c=='/')
9 j- {; [/ G3 Q* \! n, @/ w+ B                 return '>';. L# h: S, j3 B
             else if(c=='(')* d9 k8 e* c) r: J: s; }9 C
                 return 'E';
! Y4 X2 K4 t/ i4 w             else if(c==')')8 j% p  i$ _0 G% V; L* o
                 return '>';2 L7 b' F, j) G: c/ ?2 r
             else4 @9 V- P( ?2 \' j! D+ V5 ~3 m
                 return '>';
2 d# |/ T( h  q% `4 ]0 O4 A        case '#':3 v3 i2 F6 N& @& ^# `: L/ O/ [0 f! r
             if(c=='+'||c=='-')2 i# \7 Z; g5 B0 u% W5 j5 V) I
                 return '<';
& ~& Q% T2 B3 P/ S1 I. y             else if(c=='*'||c=='/')
; Y7 \0 a; U; `% U& K( ^                 return '<';
4 m& f1 h5 z8 D0 m% H2 Z             else if(c=='(')
8 R! _' p( B7 v# s9 W                 return '<';
/ [" e5 J, l5 s6 H  S( o# L/ x- S             else if(c==')')
* `% G/ |; Y, E8 [                 return 'E';0 H& t9 `1 C1 j5 k4 ^; g
             else
7 J3 @/ }: c, C) ^- S' k, U                 return '=';# e7 H# z( k5 H" H: U$ J  w( t
        default:- O4 G' g4 D# K
             break;0 {+ u3 m8 \# k
    }
1 q- ?% ]  ]9 K0 _% s7 k    return 0;   
0 x" R" j! P1 p: i2 g* F}! d' K& s1 l& a: j( y
# V( W6 _& ?% Q; S4 I
int isOpr(char c)+ X$ V- O$ V% R+ P
{( J5 o) j4 r3 y- m3 E. q7 C
    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
) O- {! Y$ [( S! B$ h! n        return 0;' ^4 H% ^2 }7 A5 C" ^% M! ?( q
    else 6 I, r! l7 s( o% r" c2 Q$ K, P
        return 1;" y+ j9 T1 u3 x7 v& _
}2 m+ ?; l# O0 v) F
' y- G1 V( k9 g$ M  S
float operate(float x, char opr, float y)
9 f6 L! c6 C) F7 U- V9 u{5 y6 Z+ T/ t5 \3 x$ b# T6 Q
    float result;
- e# `1 K) H- J5 `    switch (opr)& [- a+ k% O# u' o$ |1 w$ ]1 `2 r
    {' ^3 ~7 t; q' v& {# ~
        case '+':
7 t6 u  r: ]: J; ?6 `# Z             result = x + y;2 `, P: {# l& m- ]. C. t
             break;( R/ o3 s7 e7 ?
        case '-': : d0 ]: Q7 H% Z! |3 H* C- i/ [4 E! h
             result = x - y;
7 k8 d4 O9 [. S7 i) X1 Y+ ]5 E             break;) r4 U; v$ Y- M/ L5 b* o+ W
        case '*':
) s) M* i, z; Z1 s, n% d; h             result = x * y;
" _$ U$ K) L  T7 _5 X0 R6 _             break;( k8 _2 j( r! c0 y( G
        case '/': # i* ^: e' l# ?( k5 b
             if (y == 0)
& g3 K+ m, l, g! C( }) a             {
4 N5 v# |* y5 h( j9 d                printf("Divided by zero!\n");0 k: M- _7 M/ Z3 W; c9 b# h3 ?
                return 0;4 e, p6 S1 B1 o# C8 F
             }+ I0 R7 y/ V, ]
             else
! W8 v1 S+ A6 B5 m7 j9 b7 m4 I- W- t             {
6 Y2 o/ u: M+ O' G0 Q5 s                 result = x / y;# m9 w. ^- }3 @& t( i, r1 Z
                 break;* r1 c  O4 N7 c3 y/ v8 f% g/ ^$ z
             }
+ }4 z2 [( ]' ?, L; b8 [' G       default:
* }. i, e4 x9 R             printf("Bad Input.\n");   L% o  r, I1 M  r% i  A- o) l
             return 0;. y" S( r! o6 j# b& g
    }' N! E& \- j, O; t1 s
    return result;9 T5 ~- [+ i1 ]* J# G
}    & [* ~% J3 R. O  g, q, k) i' Z0 L

  d5 Y: B0 w4 Z3 B8 tfloat compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
' {$ f9 C9 m- M0 J* N- T, x. F1 R{/ }- }7 D' q' {, F6 S  v
    Stack optr,opnd;
( y+ \+ \& R( c$ u& a$ P    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;% ^% s" c7 s2 N* F8 E
    char c;5 _- T1 l* _7 D4 q
    char buf[16];) }: u. Q& }) a
    int i=0;
% I0 |& f, g  f8 f, D    : X5 N' t0 R, M/ W, B5 H* ~1 b
    InitStack(optr); /*用于寄存运算符*/
9 J7 ]6 W/ T$ a) l    InitStack(opnd); /*用于寄存操作数和计算结果*/3 K/ m2 r( n, D* L% }* E
    memset(buf,0,sizeof(buf));
2 i$ M; p5 ~3 Q: k2 G   
- a$ V1 q( n6 ]0 z7 l  D    printf("Enter your expression:");
" ^' j4 V2 T% G3 M4 Z& M1 c$ |$ W9 C        2 }; @; d9 c7 T# R
    opr_in.ch='#';3 i$ [: D% w9 J+ `
    Push(optr,opr_in); /*'#'入栈*/4 W3 Z& z& x  I! _
    GetTop(optr,opr_top);: b; N& E6 o$ Z# w) x4 m% M. J
    c=getchar();5 y/ V) [: ~2 c6 U  t
    while(c!='='||opr_top.ch!='#')0 S! P/ v. ]" B* _
    {! }% `) ^. S3 Y. M1 u2 w
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
! q( z- F& I6 T        {
4 d+ c- J% Z$ K9 `; w3 [9 f            buf=c;0 d1 D* H& x2 ?
            i++;" d" t/ i) y6 H  i1 U5 a
            c=getchar();9 s* ?8 B: t2 e3 {
        }7 f6 Y( @- y. p% u6 m  x3 f6 n; q4 T
        else /*是运算符*/
- U6 a- F1 v+ M$ `: Z( B1 {! q        {( {* k9 t! ?+ {9 x) W* }
            buf='\0';' K- R5 y2 u1 \2 ~/ ^
            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
6 J, u7 B! q3 J            {% e. Z* ]/ b' M+ J: Z8 S8 N4 L# s
                 opn_in.data=(float)atof(buf);
  h7 x" N! v( j                 Push(opnd,opn_in);
2 c: U% R- @, o  q1 o- e5 v: b                 printf("opnd入栈:[%f]\n",opn_in.data);& ~$ d) Z; s  T  n& x2 d
                 i=0;
  a$ }% I, @% g; G) r1 U                 memset(buf,0,sizeof(buf));0 W0 ]- M* I! |7 [- c
            }
( O2 R6 h3 p' D6 d) W            opr_in.ch=c;
% x' M4 I7 v# n            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
( c3 k( ^) h9 E0 k# O% G            {
& X+ u% y/ ?( |$ z7 e0 w. s                case '<': /*优先级小于栈顶结点,则运算符入栈*/
6 j5 W3 }; k8 G) ?' \) C, W                     Push(optr,opr_in);; K/ T: O8 W! L, V
                     printf("optr入栈:[%c]\n",opr_in.ch);
" h0 o* J8 Z0 V5 P7 v                     c=getchar();& {. H$ n4 E3 r" i( W
                     break;
2 j$ J" P3 ?2 ?* x                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/8 \+ ?2 O( X; M2 |! \
                     Pop(optr,e);
9 v: k( X8 i: Y                     printf("optr出栈:去掉括号\n");' o) h1 o, z4 U# S: w. q/ q
                     c=getchar();6 h: ]' s$ t3 v5 A0 r. ^5 L2 }
                     break;: x' |: m7 U) ~+ H, D/ H7 B  ^* k% s( V
                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
* m; }$ W4 o# ?! i: I# A                     Pop(optr,opr_t);
" j- R- t- `7 N8 H" B0 I                     printf("optr出栈:[%c]\n",opr_t.ch);0 f: f8 c- {/ T
                     if(Pop(opnd,b)<0)( U: V2 `$ m0 i
                     {' c; N! L! ]; U( Z
                         printf("Bad Input!\n");1 |5 [1 G2 \) {# E
                         fflush(stdin);# R, \) n1 |+ G1 q
                         return -1;: I* ^- m6 ]' I" }, O
                     }1 U6 r) v; A7 D
                     printf("opnd出栈:[%f]\n",b.data);
6 V6 x5 N( `: a% a9 V. T& n- J5 h3 H" c                     if(Pop(opnd,a)<0)
" s/ O; i- m+ _& A% _1 t# ?# I                     {
; G' f5 h& Y6 u; U  h. j: v2 e/ W                         printf("Bad Input!\n");2 Q5 }$ V9 x6 N9 A  G1 E6 o/ e6 I
                         fflush(stdin);
+ `( N) b9 v2 _3 ~6 B                         return -1;
5 _1 m& {. h6 A& Q, ?) E' N9 C                     }
8 X& b6 s8 j8 L, j+ j& o: O                     printf("opnd出栈:[%f]\n",a.data);1 X7 H8 H( C. s8 x
                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/. m; h' z, `) i, H) S9 {# G
                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/" f5 B* C. y% A+ H5 \4 y
                     printf("结果入栈:[%f]\n",opn_tmp.data);: E1 r* V8 `* y0 G3 m/ g! G& E0 G
                     break;9 {7 ?" M. s- Q& z3 |
            }
/ f" I1 i! u- L1 r        }
5 G; [8 `* `# q7 e. ?4 J1 Y        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/                3 E- {7 ~! a8 o7 a% o
    }
$ j8 G& S& k3 b( Q    GetTop(opnd,opn_tmp);
- T4 w9 `3 u4 r& J8 I    DestroyStack(optr);
4 }- V7 v, e  k: E8 j" j  n    DestroyStack(opnd);
6 t/ X: q; [4 Z: O( @( h    return opn_tmp.data;, P6 z7 n, ?* U. \$ g& I
}) x$ ^" j& Q! e+ Q5 Z+ A
1 l3 X& e3 u4 r3 z# @
char *killzero(char *res,float result)( E% b, ]; g9 Y/ {3 {6 i
{, Q- b; ^! ^! q3 T
    int i;
& W5 ~1 o5 Q0 m  G# p( \/ t' ]4 z5 o! W4 c/ n! H
    sprintf(res,"%f",result);
; r/ V% `+ r& y5 H# C    i=(int)strlen(res)-1;, T! c3 F, j9 a9 C, \
    while(i&&res=='0')7 B; I9 q# k) T: \5 T# z: k
    {
: j9 }. {$ I5 j$ t* o' _        res='\0';
% k/ y5 x& z  K" n        i--;
! p/ a5 d; {1 W" N    }
! j7 J* `5 W4 M9 ^    if(res=='.')
, B  u6 {2 m/ P' N9 j  s) M* w0 p- `        res='\0';4 I+ i# j6 d3 ]
    return res;
' F2 M- j  ~9 L) P+ `}2 l) {' s0 l0 {" r; P7 j( c+ N
# U9 x. q2 ?7 L$ Y- E/ u0 \/ y
int main()
5 l& [# ?8 d1 c; A0 y$ A. |. B{: `# P1 n3 ], w6 C: \$ b4 p( S4 H. s
    char ch;& Q3 r( M1 U( Q% a
    char res[64];' }  J9 X4 u% h5 ?/ d, x* P
    float result;7 S" s5 K; O  M) u; K0 h
    while(1)$ `- l# d  i( @3 V* X
    {% c$ C6 {3 K5 r5 u$ W
        result=compute();
8 X9 ?; v. \  O4 f, A+ i! T        printf("\nThe result is:%s\n",killzero(res,result));; |7 Q  ]# i# L4 ~( M2 v8 E
        printf("Do you want to continue(y/n)?:") ;
/ W& R5 i" w& @- m$ a        ch=getch();
; x8 n: o) W3 d        putchar(ch);
+ e$ M& Q5 v& F* l4 |2 `. L( A        if(ch=='n'||ch=='N')
* d4 V% ~; K) e5 n            break;
6 }% o7 b9 s' ~$ ]1 l8 O5 J& ~3 R0 |        else: ^1 k2 v  Q! N; e2 C6 e
            system("cls");1 t+ v* {  O# X
    }
9 ^, ~3 B* X/ g- S    return 0;
7 w( f: W( ?: q" F}

2 o4 S4 u- h5 o2 t! H% c2 L7 |" A' Q0 x$ G0 a5 z, N/ a
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

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