返回列表 发帖

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.! |1 b" G$ T1 L. D$ M
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
5 j8 _" l8 P) {6 D/**************表达式计算器************/
. {3 p. u7 g: S/ `7 i* f. D" o" X) ^#include <stdio.h>
; n  m8 l/ S/ x#include <stdlib.h>4 ~4 ~3 Y3 h" X- y+ _) b/ t0 Q
#include <string.h>9 e( y1 X! T  N5 ]( y# R$ R
#include <conio.h>
3 l/ e4 d. k( u# ?#include <malloc.h>
- [' G. w5 m& W5 K/ d5 [1 U0 r2 M0 b8 l4 k; v/ A  E. p6 G
#define STACK_SIZE 100
5 k. S6 r- b% ~! K#define APPEND_SIZE 10
$ X& U6 z! `, [( J
; w0 B- Z# T2 }9 A( s9 {struct SNode{
* `! J! n% S* M/ ~( Y3 ~    float data; /*存放操作数或者计算结果*/4 v) A( N! u. ~6 C
    char ch; /*存放运算符*/5 j: \( M( ]/ C+ K7 u, H
};% e) j! }% H/ O5 l$ N, n( E, _

# B3 _& E" C0 q4 i7 w9 R4 T. _struct Stack{
) d* g. F. j  O6 q    SNode *top;
, W$ y$ C! m- z* \# O) i    SNode *base;
. y' E* S4 G" u( m* m1 n2 d/ i    int size;: r8 d3 t0 G0 C+ F
};
( f" P- l2 j7 ~9 x0 |
" `; H" K+ Z$ [7 a. {5 R/*栈操作函数*/
; b6 s0 N5 n2 ]. U/ ~int InitStack(Stack &S); /*创建栈*/6 I6 }* P* r. g
int DestroyStack(Stack &S); /*销毁栈*/
# C0 {: v. o3 d( qint ClearStack(Stack &S); /*清空栈*/
! q1 }' \' r( G' L3 z* _+ wint GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/# O, W% i+ `4 o9 B" Y
int Push(Stack &S,SNode e); /*将结点e压入栈*/
7 W5 a/ H8 Y* Jint Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/+ M! Z. H5 T' X' d  T9 w/ _) X0 h
* o5 S3 E- G& V+ \, l
/*表达式计算器相关函数*/$ I7 B; l+ C# I
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
) w. y( ?- j. j( R5 ?1 Hint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
' p) ?& m  Q' K/ D. X. Hfloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/- |$ t) F' N1 y6 q/ q3 d. r
float compute(); /*表达式结算器主函数*/+ `; e  D: y/ _8 d, F" i! R! j. x
char *killzero(float result); /*去掉结果后面的0*/ & B  @& Y( N$ Q( Z( \0 `
: o2 E; _9 ]: q' b/ L
int InitStack(Stack &S)
; ^- U7 O& ]  w$ Q2 e{" Q5 @# l- q8 [
    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
8 q9 a9 O; S- Z1 w  D- o3 Q4 o    if(S.base==NULL)- F& z& |0 ~/ B& |
    {; O+ g$ x, D) q
        printf("动态分配内存失败!");, p/ T; e. u0 I# F+ @9 Q1 v- A
        return -1;
( ~8 `# l5 V5 C% ^" a# _    }% c( {7 g2 U1 f3 C4 }1 }
    S.top=S.base;
* I6 ?7 {1 b: p# T% w$ g    S.size=STACK_SIZE;
+ i  Y6 s- X, [; ^* r! F; y    return 0;
9 `- S6 b0 Y* b$ B}( [4 y5 f1 F  u* B
" a/ c* O/ D0 S1 k! Z, ]! a1 Y
int DestroyStack(Stack &S)
% Q8 l% e4 f& f- g6 T; Y. v  r2 W{5 [" ^9 x7 Y! L
    free(S.base);$ b3 `% K) D+ ]/ ?
    return 0;3 ~2 U, }# M: I4 ]" T
}
* \! w: S7 E% F  g' \" |8 M/ `8 K8 v5 F* U3 Y6 X! b
int ClearStack(Stack &S)
; k$ t$ O( x+ E* B/ n1 i{
5 M1 {2 Y4 [% z$ a. N    S.top=S.base;# r0 ~4 k: n- b1 v# C
    return 0;
" B) r3 N+ a1 O6 n% `# g! g}! r# B# h: g- ?: _$ ]( b6 F
- R$ K- T' \- o+ |3 D7 B
int GetTop(Stack S,SNode &e)2 J( e* |' a8 d( ~
{
* m# }& x* }1 P) K1 K    if(S.top==S.base)
* V1 h  w% }" c; \0 t    {' q' c+ O( z  y$ B5 a% I
        printf("栈以为空!");6 V' ^: W# q, j5 i2 v* h6 }
        return -1;
7 J. D9 V( d+ H+ }4 w    }9 R; u; v: I( G$ L6 V) j0 N/ [) R
    e=*(S.top-1);9 D# a) d3 o6 W" N) o& j
    return 0;9 b5 \; z9 H' Z" z
}
8 j; k5 |( R" p7 m+ F, o
7 c' u- e* |( ~! ~1 a& T# fint Push(Stack &S,SNode e)
1 ~% k) D8 R6 K{
/ b: U& @( k! K9 T    if(S.top-S.base>=S.size)7 k0 }7 K$ K( w
    {. P+ y% Q$ ~, E7 Y! S
        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));# A. A2 A" C  K; m
        if(S.base==NULL)
1 U* Q1 n! U8 b" V& ~- X4 C        {0 P, |' H$ ?6 b
            printf("动态分配内存失败!");7 X3 H' d, g# v3 a  c
            return -1;
5 P- D0 O' R' {# L1 \        }! P! I% }( Y9 K- y$ G( `
        S.top=S.base+S.size;8 X6 h) Q+ Y; w$ Q% ~3 |8 V8 C# ~
        S.size+=APPEND_SIZE;% \% p; {6 v8 r! b1 F5 m% V
    }
3 }- m  x6 b) e3 Y    *S.top=e;; {& N: D9 E% Z2 M3 ~5 e" W9 v$ i
    S.top++;
0 l) [4 Z  j! M+ U8 _# Z3 E7 S& @    return 0;
. y: G% u; O% r8 w' G; T$ i+ f}
1 g9 t" ~+ B# _6 @7 Q7 R4 t4 {# w; A6 k- o! d: ?0 P0 p
int Pop(Stack &S,SNode &e)
- v2 d% C1 x( p5 b- n4 P: j" [{+ R0 N  d  E. Q" O* s# k
    if(S.top==S.base)  {2 k; _/ [% {: H- z
    {4 g3 w0 J5 k$ ~6 T% b5 P. d4 @: j  o
        printf("栈为空!");1 ~9 o+ H( b" ]+ M) l
        return -1;
; Y6 z' h, Z2 Z; D* O; _    }
3 r) f! ^! D3 X" u; V    e=*(S.top-1);
$ r6 \) d; n. m. S. T  k* ^, z    S.top--;  s  Z1 }; n, f& @  T# E( O
    return 0;: {) C( t0 q8 Y! d8 o3 l0 ~
}
- j9 f$ ~+ @2 o' P! v. L- G, {- ~) @/ S# j# K. v% V9 K6 s
char get_precede(char s,char c)4 A4 h% q& E$ J
{
- _! D) s: V/ r5 T    switch(s)0 o% k' {& L) J1 V8 f% ^
    {
5 Z1 p& b: X) B; O        case '+':                 # a1 _' Q* L* K- G
        case '-':
/ T/ y) a; Q4 t: s) f             if(c=='+'||c=='-')
* E6 f- H- ?! M, }1 z/ C                 return '>';
& Y! I, E0 S- o# @# A: b             else if(c=='*'||c=='/'), |  U2 e" C$ E
                 return '<';
; }+ l- U  I' h5 f3 u             else if(c=='(')$ P& c$ O+ C0 y9 [9 f
                 return '<';
9 z" J5 |, M- C6 |' R$ W0 h  \             else if(c==')')* t4 G* D: B% c$ w
                 return '>';
2 K( c! b) C* L+ |; c             else
$ a) ?) p1 o+ m6 m                 return '>';; @" r1 C. i# J" \8 e9 |2 S5 Z
        case '*':# A( p0 v5 U* P2 n
        case '/':; C/ }$ i! N, p: Q, @
             if(c=='+'||c=='-')
% C; e  v9 D9 J                 return '>';5 J3 c, x) z2 m) F$ v
             else if(c=='*'||c=='/')
' T0 O2 b, U" D. P/ Z0 i4 u                 return '>';- t. i: n' B8 D9 p3 J
             else if(c=='(')3 Y0 B0 F7 z, O$ i$ `# x
                 return '<';
; |# v! D7 D$ e/ V             else if(c==')')
  g1 D  k7 I6 X( E7 k                 return '>';0 |/ ^7 {9 f% q$ l1 l5 k0 H
             else0 H! ]+ W: g, Z6 w7 {' S! ?8 j
                 return '>';
& t5 i7 Y" R# M0 H( E$ B1 x        case '(':
( E/ X$ }# H1 w$ s: R% i, _             if(c=='+'||c=='-')
! ~0 N; M' N8 l4 d                 return '<';
" U0 v! {  V/ b8 j7 N5 D             else if(c=='*'||c=='/')
  ?) _4 q5 m' W* ~% l6 A                 return '<';
8 E6 O& ~+ C" F) Z5 d             else if(c=='(')
" r; r* m! R+ A  [                 return '<';- Z# F' [9 L4 `" k. K
             else if(c==')')' @- v( A4 s0 m4 f& }6 Z
                 return '=';  Z4 g) P+ X$ |# G! [& o
             else- }9 D% _7 n9 `) D/ i' g7 Q
                 return 'E';8 n# Y1 J: F( O" `
        case ')':8 u; S( D2 y' c/ A( J
             if(c=='+'||c=='-')
) U- N( v& H$ r. e( X+ @                 return '>';" H# T2 R( f. G, h% V; r! E
             else if(c=='*'||c=='/')3 @- l1 E6 e) r9 p6 B! ~8 y( ^- R. h
                 return '>';
0 }( D8 e; U3 X" }: c: T             else if(c=='(')
3 M# z" i- I6 @, q                 return 'E';, G+ `2 d$ H& w* M2 k: E& v4 O
             else if(c==')')
2 m- D* G6 }* }' |+ Y! z                 return '>';
; `  S3 Y& ?! {& j, p1 F             else! ?) o3 H$ p* B: o( h/ x
                 return '>';
+ o- B: P2 _7 T" k" ]5 ^        case '#':
5 u2 v3 `2 c3 ]0 n             if(c=='+'||c=='-')
- i+ v# o$ B. H. E! T7 F9 d                 return '<';
# I* S9 h1 S4 G# M             else if(c=='*'||c=='/')
: _- n/ n* V  ^( e                 return '<';. i7 a0 l. q7 P* l8 K
             else if(c=='(')5 ]1 E: Z2 h8 I# T. ^/ L1 {
                 return '<';; s2 |1 W1 l# z
             else if(c==')')
+ j. I' W1 d5 u; z) o2 W                 return 'E';% T9 i7 D% I( k1 K2 x0 `) E
             else7 R( a0 l0 ^" Z
                 return '=';
5 w0 E% U% _+ x! a$ b. {4 P        default:
4 `* `+ q" I, l0 E% ^6 ~             break;) e; h6 L2 b% ^( M. @6 b
    }
  p# ~% u% k% k# z3 g- y  H8 Z    return 0;   
" Y6 B6 `( i( T0 w' e8 @/ s4 x% m}5 L! y( S* }% d1 G
" j$ Q4 _; i- T# ]6 X$ T7 W
int isOpr(char c)) `- b4 q3 F1 j  ^
{
8 ~: B8 t5 g& }* t/ u5 ?( Z    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')3 B8 G8 ^+ i, j+ n+ u8 Q
        return 0;
9 E/ S8 ^+ Y, m* j# H# W* D. S% |    else
* g$ K, |( m& I1 y) T        return 1;
3 a5 O* ^- D# f( o7 b6 O}
" g2 V4 y/ C- H- R, j6 R* H$ M" K1 i6 [6 n9 n: o) ]
float operate(float x, char opr, float y)
; B/ t, A9 L6 g. j: F$ q/ w{
5 a' m8 w7 k3 u' h    float result;8 W# c5 F" A( h, Y/ h7 q
    switch (opr)
, b: O0 T" r$ k  }7 q    {
, k! l" y) P( V% L/ e: |5 T) |+ u        case '+':
; o1 M/ d! R3 j6 A& V! ?6 ?             result = x + y;
; u/ `! k% \3 U0 U0 ]% N2 Z8 M             break;* V9 ~5 r+ |$ G# v$ p1 R
        case '-': 7 a5 h2 Z" O, N- E5 ^
             result = x - y;
( Z# G7 G3 I8 ]* D1 @# T" N- p: N  a5 W/ b             break;
, q8 N0 W  \+ Y( h2 `8 @: X3 t        case '*':
( f: o; e: N: M, c1 k/ s& m3 s) Q             result = x * y;) g( i1 ^% O5 d* f* J# R
             break;0 I& J5 j7 ?* ~. h+ m" K7 W- |
        case '/': * S# _6 T! y* H( H7 o) @
             if (y == 0)% a" ^! ?( U) }8 A: G* s
             {
6 C( E6 s( Y% A$ @# @- h2 v                printf("Divided by zero!\n");
, B. p2 v! z# _: A4 M7 T' Y                return 0;
) p* B8 n4 A" Z& S+ P  G0 Q/ B             }
- {2 }( Y% J# l) Z2 Y             else
2 r/ C7 T. w* g/ V! B+ r             {
& b' J: Z2 `! l, M; A                 result = x / y;
2 h5 x5 L0 u, T- h7 A                 break;
- f3 T- o3 q3 x0 s             }
) M1 Y' E1 _1 E       default:
2 N( S' J. H4 w5 [2 M8 t             printf("Bad Input.\n");
4 V' o# C2 z' I: V! v             return 0;
" e0 `5 O* c' u* T1 ^) D    }
/ g( q4 H; F4 I; }& n    return result;
' }& c& t, [3 |" P# M, X. L}    & h# e& B( t; {/ ]6 I

  M  L! m# P9 D. Y+ Ffloat compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
4 N8 P$ m  g9 a+ n% H' C0 c{. ~6 C, M) v, ]3 q/ D
    Stack optr,opnd;4 V- j7 p% G8 O' b
    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
6 P5 I! K2 L0 V* s    char c;1 `( @  d" n+ W2 s3 H& d6 r
    char buf[16];! G. J- B, d3 b$ A- `1 I
    int i=0;
9 J6 l! U# c" x    8 }+ n5 @8 n1 X  a9 h* C
    InitStack(optr); /*用于寄存运算符*/
. G2 y% V8 L/ e0 l+ p8 P9 J7 k    InitStack(opnd); /*用于寄存操作数和计算结果*/7 U6 H/ i4 p/ k& W$ }+ _
    memset(buf,0,sizeof(buf));( Q* f% \1 s3 P' `) T9 I# e) k
   
5 ~8 A. E/ Q' `    printf("Enter your expression:");
# P/ Z& L7 T3 i3 ]9 _        
, u* |2 \+ {' d: q) t+ Y/ L    opr_in.ch='#';
( Z* C( |5 P3 j! ~/ x( h$ C8 p    Push(optr,opr_in); /*'#'入栈*/1 R1 B3 m# G% ^8 K% P" P
    GetTop(optr,opr_top);% I; w: g/ h; r2 ~2 {
    c=getchar();1 a1 V' ]% E: u; z$ Q% z
    while(c!='='||opr_top.ch!='#')
# |7 I. g$ V1 W4 k6 H1 O    {' X$ N$ f6 y( a
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
0 T% W  x% I2 J+ V2 O0 F        {0 J: y* |6 N/ ~1 D; b! o# l
            buf=c;
; K5 d5 e; f- D8 E% @7 `/ y8 T            i++;% {9 e9 C% r% @( C: t* y
            c=getchar();
# K. T. d+ c* v        }" z9 y0 \4 p& G, t3 {
        else /*是运算符*/
: O1 W& \& |0 ]. i2 f  |        {
3 N; C' @: a- [3 j/ W0 Q$ h            buf='\0';1 {' X8 L/ N$ j0 A; W- k
            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
& G. ~8 M+ e% @# Z            {$ z% W* g$ c' f( X6 c& a2 b
                 opn_in.data=(float)atof(buf);
1 L4 k. ~8 v) [; `; S- m                 Push(opnd,opn_in);, e4 a7 w( M5 I) B  x
                 printf("opnd入栈:[%f]\n",opn_in.data);4 G" o% ^! ?8 V8 s- |' X* O
                 i=0;
7 _& V8 b/ x& w  L                 memset(buf,0,sizeof(buf));
2 H7 V  ?  p' C. b; C            }/ d; v: o- ~+ o0 L" t& H# k
            opr_in.ch=c;. }. h2 O4 F. O  K2 Y- Q
            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/8 ~' n& y) K! t4 \0 Y9 s) h
            {( {& y* h; M# A1 o9 ?. A
                case '<': /*优先级小于栈顶结点,则运算符入栈*/- }! x+ P% Y$ e6 b; t! V
                     Push(optr,opr_in);; c5 U: ]; L4 p: \( l
                     printf("optr入栈:[%c]\n",opr_in.ch);& ?; |, d4 n& c, n2 r" k
                     c=getchar();* |+ f) d+ Y. w4 ?  T% p+ k
                     break;: z: d" {, I% a- g+ K2 @
                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
; t8 l& n6 B, v/ L2 Z+ q/ H                     Pop(optr,e);" E0 ]; `' {! t1 Y! [! J
                     printf("optr出栈:去掉括号\n");4 @/ K" e, d+ N7 q9 ~( y4 k
                     c=getchar();+ @5 f; Q: w- M" M' F8 p
                     break;$ e# Z4 C( t! a
                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/0 e$ T4 q" C: ~5 H  q5 k
                     Pop(optr,opr_t);
' |7 B" D7 p! c6 x+ F                     printf("optr出栈:[%c]\n",opr_t.ch);
! _5 k- k; M1 l1 Z                     if(Pop(opnd,b)<0)
: }( S8 Z6 W1 l. W                     {
9 \$ I4 {. R8 E( S                         printf("Bad Input!\n");
* p; H( W% O) p0 [                         fflush(stdin);# D, {7 N/ a) u/ e2 R8 x% f
                         return -1;8 ^; R. _0 u. E5 V9 j1 N: f
                     }' E% Q% n( I  V. o
                     printf("opnd出栈:[%f]\n",b.data);
; V* l: `: G( a* Q5 R+ n                     if(Pop(opnd,a)<0): A; X2 O0 y; O7 t" |
                     {
' Z: X7 B. L4 }$ C5 j! L                         printf("Bad Input!\n");
: }. {' ^) c7 V. y1 \6 h9 a                         fflush(stdin);
2 k) y' Q2 `% `                         return -1;
$ I8 M- y3 r, n2 O" I; S" H4 j                     }% a; m; M0 ]1 ?) {# f
                     printf("opnd出栈:[%f]\n",a.data);- W0 D$ v! v/ i3 c5 V8 c
                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
' u0 T. J' Y) e7 ?) l3 D* ^                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
7 @. k. S3 k' O/ ~& s( o6 Q1 v                     printf("结果入栈:[%f]\n",opn_tmp.data);( `, C# A0 h3 U% r8 o
                     break;
- S# w8 ^1 W* E/ k            }  z4 j4 |2 |  [
        }
4 S7 H; C) e. d, N$ ?( X. B8 B        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               
- L2 s9 r0 N/ H2 N7 a    }3 U) W* v+ A) Q/ R6 M# V
    GetTop(opnd,opn_tmp);
9 v6 H$ x: h/ V+ C: j2 v# u0 c6 ~    DestroyStack(optr);
) L/ y# k) K+ @$ Y4 h( V3 p; h8 q    DestroyStack(opnd);
) e5 E: ?  ?; \6 ?    return opn_tmp.data;
8 r0 b  }* K; Q3 T0 P/ v}; a& f! M/ m/ n0 f5 V: S2 b: b
3 P6 J2 ]; \6 U$ n5 P+ z
char *killzero(char *res,float result)
& T( D/ x) v, Z{
' M8 L4 U: U  @+ B; Y  I    int i;
6 |- b- f* N& t: \' W3 B: y
/ j! I, X. T5 D& w    sprintf(res,"%f",result);
* h  b1 W" ~( x1 X, l: T    i=(int)strlen(res)-1;' m& `7 o& ^4 L" W6 R4 u, _
    while(i&&res=='0')# J6 ^8 l3 m( r0 u- B( t: Z8 o  y% B! C+ P
    {, `3 n$ ~7 v, A, }/ K" s
        res='\0';
4 W9 q7 w6 Z) \4 e3 l6 M        i--;
& `/ G$ a% ^8 u& U. G; ^% S    }, e4 p, r0 r; S2 e; b" I% k
    if(res=='.')
6 R" M7 ^( [3 _  O- T- [- k2 x        res='\0';! U5 ~0 H; m% W
    return res;
) c! |& o2 q( A7 V0 M}
3 w' Q" D0 [! ^( g& l) b8 Q0 ^  B4 L: H& d5 b  c
int main()+ @1 F* ]+ i' o2 m
{
$ X5 s# G( q7 D: T4 U6 w# C, O    char ch;2 Q4 }& Y. B: \) f1 X) G- t3 t3 K
    char res[64];
1 g% A' N. f: H" U6 q: W    float result;
  R: B/ S( T$ t* i/ \7 d6 p8 o    while(1)
9 \$ g$ c% s6 A. a    {
8 F0 e. x% G/ L8 o! a* v# G        result=compute();/ P; L6 n9 T# D/ F
        printf("\nThe result is:%s\n",killzero(res,result));
) n. y4 m) l1 V        printf("Do you want to continue(y/n)?:") ;
- b% F8 |0 T8 m" b8 C9 e* q9 `        ch=getch();
# k; @  H+ T4 ^0 ^' F        putchar(ch);4 V7 m7 F" m% ?( U9 `
        if(ch=='n'||ch=='N')+ `7 Z: l1 k1 i! ?( J0 q0 l+ `
            break;+ C0 q3 P9 ^. {9 E
        else
5 |- Q. Y& V: ^! Q" t            system("cls");: |9 I: N- E. z$ Z; M
    }7 O# A+ z8 u- U. l! x# r
    return 0;
* a# k9 K4 y- \( ]. Z( f+ P# \0 @}

& e* A  T# w& ^7 ?2 ?2 U) T/ Q$ A% f
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

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