返回列表 发帖

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
) K0 b) u1 W& b5 p1 o程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=5 r& @; p$ \) j# X+ S
/**************表达式计算器************/, O/ U8 |7 K* T% T( X4 m) V8 e: a/ u
#include <stdio.h>$ v) b5 [3 v/ A% l: f; v8 R
#include <stdlib.h>2 m! m8 D0 l" `5 n
#include <string.h>
: b0 T& G; d7 O- }#include <conio.h>
6 x$ k( @1 M% i% b+ u3 F; P4 M#include <malloc.h>
' s9 R7 q$ N) A
3 g& u( W6 C+ h  G  o#define STACK_SIZE 100/ ?1 B  @2 m; h0 ^: F8 g
#define APPEND_SIZE 10
8 h3 X" ~- ?# V
/ q: V8 b/ m9 ystruct SNode{/ c6 `: ]3 {+ ^* K9 ?/ Z. N" {; c
    float data; /*存放操作数或者计算结果*// J- E7 u5 `6 k6 z, ^
    char ch; /*存放运算符*/
% l6 u; [) g( L0 t! y+ K};
+ W3 v& I4 c6 M
- B6 `2 {1 ~6 [. s- Z; {struct Stack{
% V7 I$ y; `3 g. N    SNode *top;
# n3 s9 m) b$ {9 w( o: g5 o* [    SNode *base;
* x7 Q& a+ Z5 `: Y! y: k9 R    int size;3 |2 u( A! z) w
};- H2 j( t+ M8 v- v( e+ ~

  Q; z% j% k+ Q6 t/*栈操作函数*/4 t0 Z; Z$ X$ N8 ^1 V( J9 M$ s" U" G
int InitStack(Stack &S); /*创建栈*/3 }! M8 r0 f# l; D/ d0 [" k  F) \+ A
int DestroyStack(Stack &S); /*销毁栈*/5 F( V) b& g8 T+ k
int ClearStack(Stack &S); /*清空栈*/
) ]1 R0 Q$ s% k& F% Mint GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/: O% E8 S0 e1 h( [
int Push(Stack &S,SNode e); /*将结点e压入栈*/6 h( Q* s, @, O3 T3 t
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
: H, y  ^5 C+ J. Q7 p, \
* X1 v. Q- u1 ?/ C/*表达式计算器相关函数*/$ S2 W( |. `; N9 ]6 a8 d1 s3 v# f
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
+ K; Z# ]4 D! s% U. O: q& V6 Cint isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
$ Q4 A, M& O8 C. M: V% e% pfloat operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/! E* P$ M$ D) `& c1 Q! q
float compute(); /*表达式结算器主函数*/
9 _9 V+ ~$ ]+ }! F' q, R+ {5 Xchar *killzero(float result); /*去掉结果后面的0*/ ) C2 i$ M/ @) H% F
( z8 n. l6 u8 y: a
int InitStack(Stack &S)
8 o2 |* z8 i+ b% M{
, E8 K  G3 m0 H0 ~) ~# ?    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
3 ~! @) n% q. U% u+ j    if(S.base==NULL)
$ H: m5 O1 M! W) s    {, x$ L2 \8 ^8 r) ]  q  r6 [
        printf("动态分配内存失败!");
1 c$ ]4 m% A' Y- j: U) P        return -1;, q; P* T- x( N. r+ h% u1 j
    }
7 t4 H6 _) u) e$ W4 P    S.top=S.base;, E" v9 N3 ~8 i! c' @
    S.size=STACK_SIZE;
# ~5 ]# r8 W; \7 X- w    return 0;
2 _; P0 L" b, P2 w( P; I}
3 r. e6 W; w5 Z* G" N8 R; }/ c5 Z9 s- L8 {
int DestroyStack(Stack &S)6 ]" d/ R: F( W: V
{/ e" g* F" l  u1 p
    free(S.base);
' u5 S8 G7 H( E( U: c    return 0;
/ h/ {' O% `% E}: {' B9 ~- F- g' G) ]9 a
/ h2 }% e6 `- Y0 W( z) J
int ClearStack(Stack &S)9 H' N1 a& y3 _3 f
{
$ I: ?3 l0 Z: W5 {! a4 Y1 {/ A    S.top=S.base;
. Z( u2 W4 G: G4 i2 b1 n    return 0;$ ]: L# [+ j- z8 _
}9 j8 G! K" G! G6 e) s( O* R/ y- p

. Q3 R$ T4 m3 D9 zint GetTop(Stack S,SNode &e)
! h$ R2 R* F' \+ w{3 J0 q  @" ?' H2 C: o1 h
    if(S.top==S.base)
, M! t3 i9 u2 x  }0 Z    {/ J+ {1 L* V  a
        printf("栈以为空!");0 |; z' q  q3 s8 y
        return -1;0 p" e# M# s0 r* B- j5 r+ s
    }  R  [* t+ f3 T" r: C; y5 h
    e=*(S.top-1);
& }1 }' r3 n: }# u    return 0;
' Z7 T8 T. i  ]  |4 o; d}; E1 N5 P+ s. l# h/ p

$ i  o7 w7 K) y* \int Push(Stack &S,SNode e)
4 D- D1 A! E, l' u+ C# ?& y{; o/ r. a0 M; @( w
    if(S.top-S.base>=S.size)
# V3 U7 g8 K/ F1 m4 f# |    {" i$ f8 W8 x% f% ^# L4 o
        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
/ B! Z3 f, Q: Q" d% K        if(S.base==NULL)
0 J( d! U& A! T        {! \; b% G2 E! b$ [' F  c5 j& R
            printf("动态分配内存失败!");
! m2 G5 B  g; r$ |# V7 z            return -1;
. e/ Q( e6 w6 g        }/ h" L7 m6 C" H) i2 e
        S.top=S.base+S.size;
- x+ Q; `, r$ {* `3 X, W; @) `        S.size+=APPEND_SIZE;+ k; r7 V. O5 a9 {8 ^' i
    }
8 c7 m, k! @6 s; X7 E* {4 d0 D    *S.top=e;
, Z6 u. ~) U* Q; g; G* L  c+ f    S.top++;# P. L' ~7 y, G( H1 {% z! E
    return 0;
! s' l- D7 h7 e# e1 F6 R, L& [) r}& Z! L& n5 d& @+ [) m3 i

6 `5 g0 g9 @2 ?3 e' G' F4 {int Pop(Stack &S,SNode &e)- E) O3 [3 Q6 j; v
{* I) S& B* @' v" l. q+ G& S
    if(S.top==S.base); S4 ~4 U) B9 N2 j
    {
4 x- _3 E% b& [0 \1 C4 F        printf("栈为空!");4 q4 Y  ?( A1 t' s: @$ U
        return -1;
! I& o" }6 S" o4 ?, s+ t. {    }: Z' n$ I# @! u: _0 T' |. S" V
    e=*(S.top-1);
8 E9 \& O1 u  ]$ F' T" D    S.top--;
; p, a. I; a* o    return 0;# c8 D; Z' {3 V. b4 J
}. Y- y8 U0 ]- a8 ^8 g

  p" i4 z' x4 xchar get_precede(char s,char c)
8 c- }3 J: m, {% V7 |{
$ [. f! N7 C! z    switch(s)0 N3 c: ?4 t. x7 }. q, ~3 }& D
    {$ O/ [4 \5 ]8 ^0 J
        case '+':                 ( a( N  T+ J' W: n
        case '-':) _% b; M* i3 w- ]  `8 d& ^" K
             if(c=='+'||c=='-')& s1 R, Q$ {+ h" @- H* S
                 return '>';
  `. y+ [- s" x9 X! J) |, r             else if(c=='*'||c=='/')* H5 ?$ D* p; V2 D% f
                 return '<';' y+ A( S  {. Y
             else if(c=='(')
: V: v$ g  O7 ^" l8 Y5 J5 |                 return '<';  s- h2 \5 O! X& d
             else if(c==')')0 C- _. l, @8 i$ [, @/ l
                 return '>';
2 E: k  @! }' u$ d             else
# |+ W9 y- f: m" H                 return '>';8 L/ {5 C4 |6 Z8 f. }+ d" l  t: T
        case '*':
7 ?8 {: j5 X# ]" s1 A        case '/':5 Q; b2 N) Z0 j9 m* A! V5 z& R
             if(c=='+'||c=='-')5 c  C; F7 W- N: k
                 return '>';
# v, U( V: x$ k! h- X             else if(c=='*'||c=='/')+ ]6 D( h  `$ j1 g2 u) z
                 return '>';0 _1 g: O# v0 d9 c, J
             else if(c=='(')
+ U, G- s' m) h6 G- {2 E+ t* b9 P& B                 return '<';
& s# K+ E* q( V( {! I             else if(c==')')& v: o+ C' G& L/ f
                 return '>';
' f  A  b4 t. {8 b) f8 ^5 v             else$ r* W& }8 h$ ~+ y# {$ k+ s7 u+ q
                 return '>';& Z( B* e5 u3 j. d6 D1 y0 y1 S( J/ v
        case '(':: @6 B" W. I; Q
             if(c=='+'||c=='-')+ h( m# a- F& L* M% Y+ q# g
                 return '<';
2 \- V; I& [( O             else if(c=='*'||c=='/')
" I3 z) f& n; f                 return '<';
2 o; N" J! Y* N- l             else if(c=='(')
' q' d; P7 ~. ~! i0 G                 return '<';3 }% w; Y5 n5 {: S/ J
             else if(c==')'): c* b0 b( E$ t" ]" ?7 T/ B
                 return '=';. C8 G3 N! G/ P, n
             else
$ W7 f! q% ?8 M- {5 V                 return 'E';
  r' l' _9 {. d        case ')':
, Y- x+ X( H, y$ m             if(c=='+'||c=='-')
0 d/ G+ T4 m- K' g9 D) C/ s                 return '>';9 M, p& G$ P0 {+ h$ V$ L
             else if(c=='*'||c=='/')! S1 \$ R. V) C
                 return '>';; h) E  q4 I1 j  L
             else if(c=='(')
5 n1 E2 x5 a- M; {' r% g' F% E                 return 'E';
- {  s" V7 U! E* }             else if(c==')')
: y  j1 {( Y" J2 ?6 J                 return '>';
9 z2 H4 j; J* p) n  f             else, [$ j! W. q: ]' [0 P) i3 U# a
                 return '>';0 {. R% [4 ]$ J& `
        case '#':
3 I+ L! k0 X; }, c6 h3 O! p5 _, y             if(c=='+'||c=='-')1 P6 `; J5 g9 K8 [: F
                 return '<';1 j" S* \7 r' q, `
             else if(c=='*'||c=='/')- t4 V; D& _8 N  a
                 return '<';  x0 ?1 T8 N% F, l  d
             else if(c=='(')# w% b( F- G& v( c( ?+ h5 Z. @" v$ K
                 return '<';5 a- }! l) z; ?: E. I
             else if(c==')')
7 |- ^9 i  g( B; H1 a                 return 'E';" y4 G1 U9 X7 P4 m1 N
             else0 ?; o# Q8 Q# t6 c) w; Q1 R6 \+ Q0 m
                 return '=';! u' h9 Q0 F6 K/ r: f8 N
        default:
: M& g- L) n8 Q! x             break;) f7 X7 f2 L7 S& `' j
    }
6 t  B' W! X  r2 Y) s6 W    return 0;    , n" q2 `' d1 ?8 j
}
) O4 K& j# K& H9 ?3 ~$ x( m. c! e2 U- ?% ~, i0 a6 e) q5 Q
int isOpr(char c)
) p8 N+ s. i" N6 c- B{  n& @) E" Q/ ]. i# A% _4 I; l
    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
7 v3 O8 V6 X0 X  M        return 0;
7 P) V  \9 L. G; y7 S    else
0 }( n1 l# j0 u' E8 n3 K; u. T' x        return 1;
5 O, u; `5 U! ?/ E: C' N, p- B! N* u}
  [, b6 |+ Q9 w$ n0 N2 L& u6 V: |* V) r& x
float operate(float x, char opr, float y)8 X% o, j$ F/ d" T# q5 F, c
{! Q  x9 m) r4 F
    float result;
) s/ u2 N, o9 @4 |( z    switch (opr)/ g! s, M* t* f# a
    {
- q+ J0 `: l6 v( `/ _        case '+':
- L# d8 q0 f0 V2 n             result = x + y;! p4 r/ e/ Y( J1 A6 C7 ~7 T/ ]# p4 p4 V
             break;9 z2 I: p7 d) M* c. \( Y# _* Z' G
        case '-':
& q4 |6 d* e' ~. ^5 h) m: y             result = x - y;
" @- w% m2 I4 ], S# I! A             break;; S+ x! s) ^( p; J. e; @
        case '*': ( L( V" R$ j: F0 c
             result = x * y;: |" t) d0 Z2 d# ?" F  ?; f
             break;' Y- h/ B  N# K( ^$ x3 P3 O
        case '/': 7 u& o, s! w" I0 S
             if (y == 0)  I* ^: `0 S/ v7 \* c% N
             {+ z' `, |$ J. W7 O4 k! W) y) {
                printf("Divided by zero!\n");
+ Y5 J4 I3 p/ a( \2 |                return 0;8 N2 g. V) x9 x' b! r
             }5 E6 G$ e5 u$ [/ W/ m  E9 o8 n
             else
* A$ g* ~0 ?5 a( r3 D( q$ U6 Y             {
1 P+ g* u! T5 _) D& ~                 result = x / y;  S& z' N5 L2 n# d: \8 @4 ^
                 break;
3 ]0 `- @1 M$ P5 ?, A             }
8 B- ^% X4 S1 \% [       default:
, i0 v. ~4 ?- m) j6 z5 l: J             printf("Bad Input.\n");
/ S" x; [, W' h/ ~             return 0;
+ V* ]- N: V' r" t6 s, w    }$ R( G( ?& D7 s8 ]/ e/ a
    return result;* Y& A+ o6 t; v; h# Z! X
}    . O) S% J1 S7 F9 n) H# r

  ~4 C! y* N& U/ Lfloat compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
, j* \, x7 d& Y. k0 H6 I{
* p& |4 F+ d- E3 v( k    Stack optr,opnd;
% S' f2 ^" R) _$ x0 }1 T2 X2 j    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;& R- ]$ L- r  W: M* J9 A  l  v! w
    char c;7 u, Z2 j' P5 G
    char buf[16];4 u2 \* `+ \8 l7 r
    int i=0;
4 k4 h8 |; t" q- @# O8 A   
' G" M& C: T( J, ?( G' H! g    InitStack(optr); /*用于寄存运算符*/
& {  q3 F0 J9 v3 {! a5 ]! M# m! D    InitStack(opnd); /*用于寄存操作数和计算结果*/
1 l! g( G9 a7 P! T( c    memset(buf,0,sizeof(buf));
0 Q! f( P$ j: K) v   
7 H- |5 V0 r. N$ `) Q( h3 Y" V) ~    printf("Enter your expression:");
. u3 O0 t& z' m; @, |( P2 E1 g4 H        
3 A0 I+ F: j$ h; }( [; S- G3 s    opr_in.ch='#';
' O1 Q" k, g6 Q    Push(optr,opr_in); /*'#'入栈*/8 F3 M3 i* n- L" ?+ F5 e# @; |6 Q
    GetTop(optr,opr_top);
% u  T6 D, Z  X5 z3 i- t    c=getchar();
7 v+ Z" I2 k7 b8 P6 ^2 l2 k    while(c!='='||opr_top.ch!='#')
/ B* I( M$ c! `; F7 v' Y' g    {9 ^; u; @0 G0 D6 X
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/2 ]* E) V! w- i- t1 U# J8 \' r; v
        {( S7 W# ?( W  \0 H5 D$ N2 ^# x
            buf=c;
4 b. w4 W5 l+ g; G' J" E2 j, i            i++;6 K) J% W6 w8 n7 W! p" ]
            c=getchar();3 }8 G: ]5 |' u( w
        }
; W- a2 |  N. v4 P/ ~" |        else /*是运算符*/
4 R% M1 r# b/ l7 N( ?' m        {
% j6 Y7 N+ s' `/ v- K4 D4 X/ J& h/ s' g, P            buf='\0';
% W4 ]8 C6 m9 z  e8 S8 Q  H% @4 ^            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/3 r0 o& g: S5 t: ^& G
            {% F3 S: a5 F& M# j9 e2 Q* J
                 opn_in.data=(float)atof(buf);
: [/ z( Y) @1 t+ G                 Push(opnd,opn_in);
. Z6 P% l; [& F3 F: C0 }  U                 printf("opnd入栈:[%f]\n",opn_in.data);
/ p1 t  B, K7 Z                 i=0;
/ `% I2 l* D0 G# ?3 }6 w. C                 memset(buf,0,sizeof(buf));; \) G5 z( ^' @2 x. q) h! u
            }
, m& _: `5 {- W/ \2 j* [            opr_in.ch=c;
6 U7 }7 b9 r6 O( m7 T  U            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
- B0 h5 Q* X" w" z            {
$ h' O* R+ P5 p, ?) a: L                case '<': /*优先级小于栈顶结点,则运算符入栈*// B# Q& W" n2 {1 E6 ]8 e7 Z# w+ ~! A
                     Push(optr,opr_in);
9 l* s0 J& g9 A9 b8 ]                     printf("optr入栈:[%c]\n",opr_in.ch);
' U6 h5 `) `9 ^4 F) f1 J                     c=getchar();
( t. R- |- n. |3 G                     break;
* ^% {* U$ L6 S$ r6 P- ?, ^2 ~- [                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/; _% g5 \8 {% c* z! y  ]: X
                     Pop(optr,e);( v; m  k. \8 d" a
                     printf("optr出栈:去掉括号\n");
6 c; t8 i  l. X1 S                     c=getchar();7 D/ N2 U  O; \, K) U& x
                     break;# a2 _/ L+ h) k) E6 w5 d5 F* ]- s
                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
8 K2 X( [$ ?- f) r                     Pop(optr,opr_t);& M) p& @( J) J3 d
                     printf("optr出栈:[%c]\n",opr_t.ch);# S2 N* Q, G( j
                     if(Pop(opnd,b)<0)7 N8 z  m$ I! l4 a, D
                     {& b, T; Y4 r# N$ J  V7 ^/ c
                         printf("Bad Input!\n");
% Z/ Q/ Q& z, Y) u+ J7 j, r  C+ r( c                         fflush(stdin);7 L9 b! s; T0 ^# E8 B
                         return -1;
6 g! f4 u! t9 y. F( r                     }8 d$ {2 p2 [: e0 Z! [! t- I6 w
                     printf("opnd出栈:[%f]\n",b.data);
1 w. d" M8 Q, W" r% v$ x                     if(Pop(opnd,a)<0)- s* u1 _3 a7 t: Z& [' ~" r
                     {
" Q9 N% A% _" L8 m& s                         printf("Bad Input!\n");
3 t' b* n! D7 l5 ?                         fflush(stdin);
) T* F4 l6 C3 m6 t; N. P                         return -1;
$ F3 K9 E! p  [0 }                     }7 t( d, o* l1 [9 L1 e& `
                     printf("opnd出栈:[%f]\n",a.data);
0 j! C. S; N% h8 v  c( X' [. T/ s                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/7 p% Y8 h, f2 U
                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
% e# v& b. O( b; r  {9 X$ _                     printf("结果入栈:[%f]\n",opn_tmp.data);6 ~  h0 _% p1 u4 _; C
                     break;/ X7 ]( \  q' S6 a0 G& o: Q6 {
            }/ z7 R) o' n( s6 b$ x4 x% A  g' N
        }# J" p# f9 i9 D2 _1 T: S
        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               
" |$ M: Z9 f* t! `0 z9 D3 _  I    }
2 c3 H7 l; U) u3 G9 p3 d8 R; f    GetTop(opnd,opn_tmp);
& q6 @% J: Q" u6 d* y8 V    DestroyStack(optr);
+ O# C6 m8 N2 |5 m    DestroyStack(opnd);
* n; P& R& _' R" @    return opn_tmp.data;2 x* S$ Z; _" A( M1 ]7 |! P) p: Z
}
# X: v  b; L  ]+ W9 ?* l4 H3 P6 e, r, R6 ~( h
char *killzero(char *res,float result)9 {6 G- b# P: ]) F* Q: }1 ]( ~
{# |& G, z9 Z; p' `8 Y0 A
    int i;$ W& X' k( b- T/ d" c4 i
0 V, u, W5 P' L9 g
    sprintf(res,"%f",result);3 x/ y7 M+ ]& D# O" D+ N% p
    i=(int)strlen(res)-1;
. x& `# A; k+ }    while(i&&res=='0')
1 _, `5 Q/ L, q3 M2 W7 D1 F    {7 T5 u- v& A4 ]. t3 }
        res='\0';6 _0 _/ |6 J& \( l' b+ B2 G. _) c
        i--;( a/ a8 z+ u8 O6 F7 n) ^
    }& Z- E* c, N/ }( {
    if(res=='.')
6 g1 d5 E; {+ \        res='\0';
7 Q9 v, P: G% O6 z6 G) ]    return res;
% M. B/ Q! V' K6 N" `; ?* n}7 [! w* x3 n9 ]0 n
0 c! |6 a  l9 J* E  `+ H& J5 G
int main()
/ s: F) {7 h: _6 z4 Q{
6 M: ]  H9 {: ~5 A; B6 @    char ch;; [, t) b0 p: U0 x! s4 I& I
    char res[64];4 f4 U9 k2 U: y! u3 J9 l, y
    float result;
2 o0 {4 a4 _1 q4 k    while(1)
5 J0 n0 T" b) b% L! ~8 M    {
5 w$ ^3 A6 e! T) H* D# W, \  f; F        result=compute();, }/ h: \: z+ k2 ]3 \! ~. e
        printf("\nThe result is:%s\n",killzero(res,result));# J, ~/ v1 W3 W( r6 f* [0 N
        printf("Do you want to continue(y/n)?:") ;
+ ?) n+ q4 O! |4 }1 I; Q8 x' a+ z        ch=getch();
( Z( w& E: v! v1 {) l( M        putchar(ch);% A5 q# ?: I1 u( I
        if(ch=='n'||ch=='N')
# i  ~6 a/ @, x            break;
* k: v! i2 t/ M/ R' ?        else
( r) E5 n( I( k1 Z0 X1 f) ]$ H            system("cls");
3 M) i2 x. @2 v! T    }8 a6 \+ m, e+ k% ?+ D  S
    return 0;3 _! D, s6 D; N$ U0 c
}

7 F  s5 Q5 a1 x9 ^+ t" D. z: w8 Q( Y0 Y8 O
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

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