Board logo

标题: C语言表达式计算器 [打印本页]

作者: zw2004    时间: 2008-1-21 17:17     标题: C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
% @# d- N9 F! a1 b" q# K程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
9 n/ h% b  j0 G" u# H/**************表达式计算器************/: X3 o+ L' K3 }! w
#include <stdio.h>+ d0 V0 j. W7 ~* _
#include <stdlib.h>
2 P$ n8 U: h& [0 F( Z0 \8 w#include <string.h>
: r% W  r7 b6 M. L' K  Y#include <conio.h>
/ O8 y5 H0 ~" ]  H" {# e9 R7 w#include <malloc.h>
+ [; A6 u$ h, Q# X8 u
; @  E/ ^. X: a, y8 M4 N2 B#define STACK_SIZE 100/ G% H2 S+ A0 y1 {4 r8 y9 I9 Y
#define APPEND_SIZE 10
/ J9 ^  i& z; y, U7 @6 u4 S/ ^; L" B$ S  U6 u7 R& C8 u8 L
struct SNode{( E2 ~9 M1 y7 I+ ^$ u% m
    float data; /*存放操作数或者计算结果*/
" |3 q8 Q9 c: V" O    char ch; /*存放运算符*/
' d7 m( N' i0 H  H5 x  G9 p! K};8 B$ @( H0 T- |5 @1 s
/ O7 b" l! t  o3 A2 M  B1 H
struct Stack{
7 r2 R( F9 E' @3 \; a) ]    SNode *top;
. M+ x9 V* B* j- {    SNode *base;
4 l8 _0 f3 d6 I' R# d    int size;& }9 [5 v% I5 b5 f; q4 N
};
- _( @' A6 E: I' t% L; N5 V' u4 g% K* s: x" T5 U* P) b4 D
/*栈操作函数*/
/ c' T9 x! L2 D/ Aint InitStack(Stack &S); /*创建栈*// l. Z4 X8 s7 q0 h4 K! h
int DestroyStack(Stack &S); /*销毁栈*/
, ~2 y1 Q+ D' {$ rint ClearStack(Stack &S); /*清空栈*/
' H6 h' k8 Z& b3 F  P* sint GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
! I% y, Y! E9 y5 K0 ~int Push(Stack &S,SNode e); /*将结点e压入栈*/4 B; j+ F: f: ?, r5 v6 K$ A/ p+ S$ Q
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
* L" V/ h+ ~+ `. t4 N5 F4 b( D3 D$ H; a9 @% A% w& N
/*表达式计算器相关函数*/! R6 U' v1 f0 f4 e4 O$ q; S
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
9 d2 A7 K9 s5 g# J' Cint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/+ M0 s, I4 l' i5 D
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/) n  c" m* u! @( V, }
float compute(); /*表达式结算器主函数*/
& H' t) I) O7 M! y+ X! Nchar *killzero(float result); /*去掉结果后面的0*/ 2 y: X! F" n8 G7 c1 c

9 X8 T8 [( N3 @2 Rint InitStack(Stack &S)% b# ^/ r: p; @
{1 j: N* r5 J* l8 j  P. q$ _
    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
6 u2 J2 ?, E$ n6 T  o* x    if(S.base==NULL)
: a0 ^8 X7 U" P- g    {. {' Z! K- B4 E2 y7 _! a! V# w* V* I
        printf("动态分配内存失败!");# r& x8 R) ^5 n4 `1 R6 @! g% s( G1 D
        return -1;6 C4 W2 c. F$ s$ Q: I4 L2 z' S
    }
  ~# w+ r! ^7 f1 Y% e' |5 A7 t    S.top=S.base;+ S+ n0 d2 y9 M9 }: C( u1 D
    S.size=STACK_SIZE;0 `- T$ y+ r: L' o+ A- J% x4 k6 U
    return 0;, t& Q- J' Q0 I+ v. l8 H! g, p
}
8 Q; L0 r: c2 w7 E7 c
* [0 M) y$ r0 K$ Jint DestroyStack(Stack &S)8 A* P* |0 w: C0 D
{
9 {& Q4 w$ t5 v- q+ |* {8 G8 J    free(S.base);
/ e! O- w$ F( a% Q$ s    return 0;
2 d7 F1 p) d6 d0 C) `6 z5 j}
) F% p+ l0 l, `5 z! ?/ c7 Z3 K* x0 J( X
int ClearStack(Stack &S)) J8 K, X4 Z# r% y
{
2 ^: ^! z! _0 v+ n4 K0 c% @    S.top=S.base;# h7 W9 P# Z: k$ F& j
    return 0;( p) [3 T$ v$ ?
}, @) Q$ \: H; k2 z* ^! g& f
) S2 Z, E* C2 v9 m: C2 E) v# s
int GetTop(Stack S,SNode &e)5 W" K) \, u# L% I) U
{% [# _6 `! O. h5 E6 Q% f
    if(S.top==S.base)
8 i+ U" T. g- i4 G8 ^' g) Z3 i    {
2 B! F6 H: {0 L/ k" ?$ ~        printf("栈以为空!");
+ W# |* m  {2 t" l8 v& }        return -1;
# `  E, Y6 R) x6 z0 U    }% O6 w: t. w3 B/ D
    e=*(S.top-1);
  ^7 U' c" K: X' ?( ~    return 0;. C% r6 t* ~% M- j- E
}
1 r' Z0 p' ], C: X: o7 c
  q1 s; g1 F; ^- X) u. S: t; f& gint Push(Stack &S,SNode e)7 g8 f8 |5 T! y; G  W  y+ |
{1 i) H. J+ M' P- Z  H% D% h
    if(S.top-S.base>=S.size)% q9 m" ^! ~- ~( Z
    {
: E" h  A; ~, ^        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
3 C, }8 X) h. ]( _        if(S.base==NULL)
/ o6 q6 A. R3 W; N/ F! R% [9 {        {
% ^+ _2 O" \# O. k8 a            printf("动态分配内存失败!");- \( W2 d/ v+ `. T- z
            return -1;
% G) ^& o! c4 O8 E* B/ ^, V        }0 O" J: s+ {$ S0 @- }, S
        S.top=S.base+S.size;
# W( H% u! i, E" E3 T$ _! ]        S.size+=APPEND_SIZE;
  j' ?0 K% D) }: X7 Y    }" @: g, m! z% f
    *S.top=e;! g% Z8 a) E" V1 H+ D
    S.top++;! ~' J; y& z/ Q8 b
    return 0;
2 }7 S1 F" y8 z  ]6 b* f: k8 n}: @& a2 |2 o% A9 X9 D

. u) J6 N0 e! c; d5 A* }int Pop(Stack &S,SNode &e)
+ G8 L7 M/ I( A, A6 w* l{
" ~2 |7 U6 }; P' R5 n; M    if(S.top==S.base)
, M) R# q) R: j( \" o- s& c    {0 Q, j- N7 o' o
        printf("栈为空!");. I8 j( `5 Y& y0 t! T
        return -1;
) ^; e& ~, L0 X    }2 F2 R. P* o( x- W. K$ k
    e=*(S.top-1);
; D" H& W9 O% H# F' E6 q; `    S.top--;
3 \6 `) |4 Z/ m) v) k4 J    return 0;* p6 S+ t% }. Q% U2 y* E
}
3 `' Q6 S: `: |2 z, M$ G% {/ J' N1 R- s  g. }$ |5 U1 P) U# T
char get_precede(char s,char c)6 S4 C' j8 M* g( m
{0 L! x6 Z/ ]8 s7 G9 f- m
    switch(s); [. ]4 I, u# x! f3 |! ]: g. y$ ^
    {
2 z9 ~% N2 |6 y5 d$ P; ~        case '+':                 
* E( z& U* H7 ?9 b& Z        case '-':
5 h2 D8 e: ~/ F  B. Z- Q2 f- |  R             if(c=='+'||c=='-')7 n* Q( }. v1 i# t8 N% Z
                 return '>';& ?& Z6 m8 T: C6 X1 I
             else if(c=='*'||c=='/')/ x9 k& ?7 Z+ c! \# r- a
                 return '<';
$ k" A' V5 m  h" u             else if(c=='(')4 Z( S/ g1 D5 ~" ]
                 return '<';/ P3 L; T2 Y) b' s& o5 Q
             else if(c==')')
, H; V4 K* X- z5 h; D/ P2 m. [) R                 return '>';" l  C1 |) ?# R& W
             else
1 I, K$ L- c& J2 M                 return '>';
( k, w" p" \2 A/ C# ~7 L5 ^        case '*':- ?, H5 @/ i/ S% b, d
        case '/':
% M0 Z( g4 k- L  A5 ^1 J" x             if(c=='+'||c=='-')/ y, b2 v7 P" b
                 return '>';
" ~; g2 H. V$ E! g- R5 Q             else if(c=='*'||c=='/')# Y$ `; ]+ M9 ]; r9 e
                 return '>';
7 I7 l: v7 ]; E+ r8 t5 m) c             else if(c=='(')! ]; b: Q* N7 H% p, W# E9 A
                 return '<';
9 m: a; t; N4 p) s, q! W+ @             else if(c==')')
3 `$ A) G6 a) C: Z4 b: w2 s; h                 return '>';/ T- u' a* ]3 T( b) T, L* S
             else
' k4 r' g& t9 V5 j$ b3 K                 return '>';
2 r+ }6 j! O  ~: w( s) q1 \        case '(':
3 Z4 i5 j; l; a             if(c=='+'||c=='-')* ~7 W( G$ I9 V& \2 w/ a  Q  f
                 return '<';4 ?+ c. t9 a( ?% X
             else if(c=='*'||c=='/')
3 n) u, @. g% U- V8 W8 c. l! ~                 return '<';
# e3 s, ]/ C1 U$ s" P& }             else if(c=='(')9 O2 @5 E1 z! ?. K' m, S8 s. P
                 return '<';
+ l% [4 o- O$ y$ d5 c) z2 b             else if(c==')')
* O. g6 u, D0 V( B7 |; w                 return '=';
! \1 G4 m( @* O$ Q4 F( O             else
7 W2 `9 B+ E0 E& I2 m' e                 return 'E';
+ v: |0 f8 o( N7 I6 K        case ')':
2 b7 M+ x- q2 e# G- J' z             if(c=='+'||c=='-')
  F$ ^# X# _: Y0 K                 return '>';# W) V% Z1 |( r
             else if(c=='*'||c=='/')! M6 ?: A4 `% i
                 return '>';
6 [4 n3 P! m9 r4 F3 n) G  h3 F             else if(c=='(')
- I( ]" N. t+ c/ }/ R/ U. d) l3 G                 return 'E';) ]$ Y6 K2 j3 p3 A8 O
             else if(c==')')
' J% K2 C- c3 J4 B' G                 return '>';
* L' A7 V; N7 O2 b0 J             else
/ G1 t' b$ \  ]4 E) C                 return '>';
5 g5 e$ g5 R6 i- K6 s( P        case '#':. G. g2 f; K: W) b
             if(c=='+'||c=='-')1 W- D9 Z9 f) D( n  x: c6 _
                 return '<';/ C& J- k! w; ~6 Y+ ~7 E
             else if(c=='*'||c=='/')
- t6 `  `; X8 k! @: B, P                 return '<';% Z( J8 I6 J$ Q( U  E; ~5 n
             else if(c=='(')) w+ G+ L! W0 X- v% j
                 return '<';9 \% L; R' i) A7 N6 j
             else if(c==')'); K' W: K9 u0 N- G. D" b% n
                 return 'E';4 |, Z" Z2 q; I
             else
6 ~! h& s, C) k1 C, Y5 e4 P                 return '=';
/ ~0 G# ^( J8 c0 m, b6 b9 c$ S        default:
0 f5 T4 O& w7 x, C5 ~             break;
7 y8 t* ?3 g& N# `& `6 \  D    }
# K, v5 c" N7 d% W    return 0;    ! f1 u. _, F* Z& }0 [! B# V1 P
}
# X- l& N9 j* u- R1 R- E' ?  o
. ^$ q7 V: N3 qint isOpr(char c)
( ~* y9 O$ U9 F  {( h{
7 d+ g$ `9 D( s& E) P6 }1 a7 T    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')& t% O4 \5 p$ e; r( ?
        return 0;0 [( \& S7 C4 k( r. w* x4 ?3 \
    else
( |' g7 k, K2 G: y        return 1;9 n0 E) H6 b5 V- @: T
}
' C2 |; F2 S  I4 k" t7 H6 f- R) g
* M% u3 M6 M; ~: O( Gfloat operate(float x, char opr, float y)
. b9 w6 L, [: {7 F0 w{
0 _9 L2 [) Q. G8 D% I    float result;
: a4 v% m1 T  s7 a; W& G3 l" B; f5 ?    switch (opr)+ M1 X& g+ i  J. G
    {3 G  R; D; y+ K7 W" R
        case '+': ; X4 Z  u5 m. X- ~4 \$ `
             result = x + y;3 A( i" B' B8 c; F0 i( c& E
             break;
6 `4 n' j- [& J; |( B( c        case '-':
) ^/ w* ?/ t' p5 m  e             result = x - y;
( ]: B8 V: f0 X; r) [, Y             break;
& T9 R2 X; w4 j        case '*': 4 @2 g+ r- Z# n- V' C
             result = x * y;
- X  \/ c/ V9 r* c2 {- w. J             break;8 I% n2 G; t' W, R: ]
        case '/': : k& w% Q. A6 Z9 c+ |0 M" O
             if (y == 0)
8 z2 `% u' C* y+ E* B' x1 k             {( W9 Y- S/ M& F
                printf("Divided by zero!\n");
% R7 g# ~0 \& h                return 0;3 d2 {# G% d7 o1 e2 l/ _$ f
             }
7 G7 \. C; z! L$ K3 o: `' s             else  k: t# ?3 N2 n7 Z8 a  q; E
             {
0 t# i" a/ E1 f; i                 result = x / y;7 }% g1 y& k, I
                 break;$ _* Y) X5 b& W- m' v9 R/ |. _
             }$ S* d9 X: ^! g2 j
       default: " X* I  {4 d9 N) H  y" z9 r
             printf("Bad Input.\n");
3 h2 R$ a3 [7 W1 j# U             return 0;
0 y" o2 [5 g0 m$ Y    }3 y- b, M- B: c2 _+ D
    return result;3 @) n# g) T) h7 Y- w2 B
}   
9 S& u' Y4 V6 J% \( [% P7 w8 |4 q+ g4 I& d/ Z
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
, ]. n# b1 o  l: `. K{& O5 F' w  ~' b# A! \5 a* p5 o8 e- c
    Stack optr,opnd;
, D9 c1 Q" s! L- {; R, i    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
- A! i1 b4 W0 N& V    char c;
, }, R- J2 I* S, X3 n7 ~9 ]/ ~: R) e    char buf[16];2 R1 w! T& u# X4 O% W2 L
    int i=0;! P# R" P. R! a
   
* I" h: b9 U8 _) q& ^! S# M    InitStack(optr); /*用于寄存运算符*/% U" d; D" X& z* ^
    InitStack(opnd); /*用于寄存操作数和计算结果*/
$ q6 v. ~; J3 J4 F1 D% J: R* m  H    memset(buf,0,sizeof(buf));7 F+ z# I& @! m
   
+ ^" {5 q. ]# q$ |6 \* q    printf("Enter your expression:");
# z% e3 n2 K: I2 b6 N! X        7 G8 T3 ?: v' [3 i2 f! R6 q- _
    opr_in.ch='#';
& l- F$ _8 B2 R/ a& _8 r/ Y1 M) V! J  G    Push(optr,opr_in); /*'#'入栈*/+ O" i/ N5 L" n! w  U
    GetTop(optr,opr_top);
3 O  k  r" V2 _: l" A3 Y    c=getchar();
2 f; E$ [5 x( M9 J3 y# M    while(c!='='||opr_top.ch!='#')
( |0 L+ t: @5 `    {/ p4 x, ]1 O- t4 Q  `
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
) G# i' O$ P9 a        {3 M4 A! a- p) h5 g- w4 D
            buf=c;
$ o& s' _: e0 n' m9 d7 k            i++;6 `& O& f4 @: i& Z8 u
            c=getchar();1 n* u3 _$ r% }5 `) _2 y
        }
- P  P' w6 Y- u. |2 G- j        else /*是运算符*/
- M0 m: X/ l' b0 o        {# @: O6 I" K# M3 X/ h% E
            buf='\0';, l/ L8 v: \1 {7 t! w# r
            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
% A0 u1 G! x( t" ]3 b7 U            {# a1 |# p5 m# ^  }+ X
                 opn_in.data=(float)atof(buf);
3 Q- g. `1 ~- S; A" r                 Push(opnd,opn_in);
6 B% }- P" W; G6 @. z" e% s7 `7 I                 printf("opnd入栈:[%f]\n",opn_in.data);
- |( f( s$ N- P5 W  P3 K# P                 i=0;1 j  c# C0 c, D
                 memset(buf,0,sizeof(buf));0 d& x; G7 a5 U) f  K+ m' p* H
            }
+ O9 u/ d7 U/ r1 c& X5 q6 w3 V4 X            opr_in.ch=c;
9 v! R1 {7 S9 J; s; x1 k            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
0 K4 |) b$ y, d$ u            {) m: R7 Y6 A: Q( a
                case '<': /*优先级小于栈顶结点,则运算符入栈*/
9 E7 B) g! M/ J0 I$ K+ V                     Push(optr,opr_in);4 m7 _/ g; W! ^" t  e
                     printf("optr入栈:[%c]\n",opr_in.ch);
2 B7 J" x/ r0 I" A0 m; y                     c=getchar();
7 u! a& d9 c$ a: E                     break;; h' n0 x7 |$ @/ p6 R6 T( \- o
                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/. o. H$ X. L5 O2 B5 f0 Z  u5 U
                     Pop(optr,e);
$ e. g8 m# ?  i' S4 I                     printf("optr出栈:去掉括号\n");+ O+ ?# }+ V& S. g5 P
                     c=getchar();
, l- E, n  N2 Q$ K                     break;) u2 h" g* Z9 _1 F+ x, B- s5 r' v
                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
' k$ f( m$ K0 a; m8 K  M  ~                     Pop(optr,opr_t);
9 j" y* ^) ]8 E/ c                     printf("optr出栈:[%c]\n",opr_t.ch);
' b1 @/ h8 k' H5 n                     if(Pop(opnd,b)<0)
) Q& {7 d/ T- G, z+ W# Q6 v                     {* Z- B7 N0 @* c  N6 j. p
                         printf("Bad Input!\n");  {. _" ]1 t+ {3 l' I5 l
                         fflush(stdin);8 _5 P# j) L- i  D6 M) k* j5 e; Y* S
                         return -1;
% {1 e6 }, f: k                     }
4 i0 G0 y, z" Q6 b8 \                     printf("opnd出栈:[%f]\n",b.data);
; t% b* M, X. r' i5 c6 H/ }                     if(Pop(opnd,a)<0)
% f! S4 L5 m* E" `                     {
) E6 v  u3 v5 S' S3 a                         printf("Bad Input!\n");
- v  ~2 A# M$ u7 J                         fflush(stdin);$ Y4 j; n; L+ l4 E* [
                         return -1;
5 F& h6 L7 ~* A" _9 X# p  x                     }
/ k% I  j# j2 v5 v# L1 |% z                     printf("opnd出栈:[%f]\n",a.data);% S: a6 B& c& K& A/ ?3 I
                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
, B  o% r% {) G5 F4 p                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
0 R4 u. m; S$ w                     printf("结果入栈:[%f]\n",opn_tmp.data);- \* O0 ~) x' s0 _( ^
                     break;
: [3 m+ X9 v; {% {) w            }
+ m- f. C% C8 [        }# p# C7 L" l/ m" V# n! g
        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               
' v# h  U/ n+ \8 d9 ~2 q    }$ |, V7 N! s8 f; t3 f( q% Z
    GetTop(opnd,opn_tmp);% c1 p; w( I" F& M
    DestroyStack(optr);% e2 m6 I1 R8 A5 p; A
    DestroyStack(opnd);8 K. S$ v2 o8 N4 M" y( x6 n9 E
    return opn_tmp.data;: W* n! T! V5 s0 A) n
}
" h/ @5 z* t- E5 n8 ^% v1 |2 N; w, b- M' X4 t% q
char *killzero(char *res,float result)
! S+ q9 y, g& s' f{4 P$ X3 Y' p* g, v3 N6 T3 @
    int i;; `1 K5 n$ Z9 J/ Y

- u# c7 j( e# a5 Q    sprintf(res,"%f",result);
: F/ \- R' {4 d) d) H    i=(int)strlen(res)-1;( d$ J4 b2 N' S/ d% C: h
    while(i&&res=='0')
% m5 y8 G+ A: l( \/ M    {
! m7 _5 j6 F1 A% ~        res='\0';
* v9 L+ \  S" M        i--;8 @/ v: s$ K! l( I
    }2 o  B- G0 S0 x# r5 w. j$ w, V
    if(res=='.')
# j! q* ^( r  W3 b5 }        res='\0';# s2 X$ E) o2 Z0 _1 S
    return res;0 K2 {; `( z, i+ B0 _+ V- c, {' r
}6 T2 r7 a, N& e+ w" C# X/ a3 b
, _, y  q/ S5 `) K, x
int main()
) x2 [9 X1 S* g: z1 y- W% ^6 E) }{- A4 r; r- C, c: Y  h) {8 i0 x2 |
    char ch;5 o8 \# E. x6 Q7 c* \! I
    char res[64];7 `/ P3 {" _' p2 Z" v
    float result;: g2 [" m( s+ K% Y, |" N
    while(1)1 r/ Q* o) N, k* S7 u3 W
    {/ U- X! r: E. i( E6 ~
        result=compute();- q! Z! W" Y9 p! n
        printf("\nThe result is:%s\n",killzero(res,result));6 d( e) p% @# T( y0 d7 Q
        printf("Do you want to continue(y/n)?:") ;
1 |9 [5 V3 {6 [% u: }# s/ H& s        ch=getch();$ K* k0 B; ?0 C( v7 b6 j
        putchar(ch);
. h; t3 w6 L9 J( d* P2 _% {+ x        if(ch=='n'||ch=='N')
' g1 x& n5 |' G8 e* R9 Y, x            break;3 m7 }( N% t: Q  h6 T* A
        else; t5 t% b: Q6 M7 H) ^
            system("cls");" t4 b! K0 c' G! q' o
    }  d0 E/ z0 ^0 G4 A/ _, R& o
    return 0;
1 Q6 m! N1 c4 F/ S  U# R& {}

" }$ r! B/ e) s
" g% O+ @. ^) ]" {" x0 `[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]




欢迎光临 捌玖网络工作室 (http://www.89w.org/) Powered by Discuz! 7.2