返回列表 发帖

C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.# |" D5 F/ u6 g
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=. s0 I& p  o" d, P5 K3 T) |3 Q
/**************表达式计算器************/
" E) v6 g6 z% e4 K#include <stdio.h>
- t* T6 E' a# K- B5 \9 ?#include <stdlib.h>( P% s9 y, p) I% W
#include <string.h>
* i3 w' d, m% y& e: Z#include <conio.h>
: M4 S0 C0 f3 R2 ^7 w#include <malloc.h>
) q) H5 i5 n7 H, h: c0 }7 y) Y9 n, h9 Z2 v" j% h
#define STACK_SIZE 100. y/ L1 P- K6 A1 _, p# p6 a
#define APPEND_SIZE 10) S( n6 b+ F. F# P
! `" n$ _& B! e, r  s$ F
struct SNode{
. S" C& R8 v% Q7 g9 Q# S    float data; /*存放操作数或者计算结果*/
. H& }4 @- K4 {. }" U( `4 o    char ch; /*存放运算符*/
' L/ {! K  E- N) d9 v  s( U};; \0 i# x/ k( S7 d; T) T
. `4 D! u. v5 y  q; Q$ d) C
struct Stack{% L& a$ W' Z& S! _& p
    SNode *top;( L; v- s6 g& L5 [1 o% P  p% b
    SNode *base;5 d% h( r4 z3 q) t
    int size;) `% j" @# X; Z3 v. z: `* O
};
: Q" ?, @+ z0 E4 @6 k
1 O+ M- N# q/ v& N1 t6 W/*栈操作函数*/
$ j) ~0 N( |+ a) Aint InitStack(Stack &S); /*创建栈*/
. ]* ~( o2 c& Y8 T. Qint DestroyStack(Stack &S); /*销毁栈*/& n0 \1 V7 i, G# d# r& R! a, V0 u
int ClearStack(Stack &S); /*清空栈*/: y% G& ?6 W; d# C
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/1 `5 ?% R/ q( b5 V& ?$ w
int Push(Stack &S,SNode e); /*将结点e压入栈*/! s) G2 _  m! o/ E/ L- k; s
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
) I' r1 ]5 b) o! x' |
0 b! i% W. k: F: ?7 I0 K/*表达式计算器相关函数*/
8 k- F( N; q$ V! T6 U9 @3 S& _char get_precede(char s,char c); /*判断运算符s和c的优先级*/, P" a" q9 i1 H5 _3 A' T
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/! g% w0 R, h% r% [0 s: J5 j; u
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/0 {$ n' r7 y8 k, _7 x
float compute(); /*表达式结算器主函数*/
+ b* l# v0 I# A0 s$ w2 uchar *killzero(float result); /*去掉结果后面的0*/ 5 C4 p, U- k# v, ~; H
8 X, B. K. X  C
int InitStack(Stack &S)
$ [5 }0 B3 [3 H% j3 m! G+ D; Y( O{
% t' z& C# c3 Z5 ]4 Y    S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));+ \% t+ y: v" Q9 B' ?
    if(S.base==NULL)) U$ ~1 m( b4 b9 P( d( v) n- y
    {; O+ Y4 }8 {3 `' F6 z
        printf("动态分配内存失败!");
1 Z5 k* O# g& Q        return -1;# u! C8 O5 ~$ N
    }
( t* T9 p& v4 {" N- }    S.top=S.base;/ Y6 O. r2 }4 A
    S.size=STACK_SIZE;
! B: F7 j0 N& X9 e9 i    return 0;+ i, I. [5 J( G
}4 o* }1 Y% W" ?& x) R9 a5 a
: l, w5 c2 b  o2 L! m( M
int DestroyStack(Stack &S)
( H$ m/ ~5 f- Q% m1 s7 W8 x{
3 Y5 }1 f: [( W8 M+ X    free(S.base);
* `8 O: |7 d- c! V- R    return 0;" u! \: c$ i" `* W1 ~
}% q. Z; @9 v% Y
3 d1 w) @# w# \# ^- X
int ClearStack(Stack &S)
( o; H5 [+ `! C{
; P# h4 M) ~' J; L    S.top=S.base;; v/ t" o) j2 {  r* S* b
    return 0;
6 G* w1 ^' x% k7 a}3 P- `  Z* r$ l/ O, K: T  }

! a+ ?: J6 j6 k0 ?6 b& ]int GetTop(Stack S,SNode &e)) ?7 ^7 |/ j' g! V7 B+ a
{7 I' j, k( i5 ~9 `8 q& O
    if(S.top==S.base)( c! n, j; v" e# w. i9 \4 _
    {/ r+ o5 _7 `+ _$ V
        printf("栈以为空!");" Z/ ?& m7 S/ J4 ?, ~
        return -1;' u% {; b& Y7 E. J( l. t
    }
: z+ n$ O" m# I& C    e=*(S.top-1);
# q2 K7 x0 z0 s: q  G3 q# t$ \9 P    return 0;
3 d/ _& u' Z( v}6 n; U  \  H9 y
6 @  x' r" w% c3 ]
int Push(Stack &S,SNode e)6 s* }; z4 e* a+ S
{
+ P7 q/ U7 c6 a    if(S.top-S.base>=S.size)9 t  r8 y+ j, O! L% f: \
    {2 K% d5 s+ c7 y
        S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
2 @- X: Y- P  s( s7 h        if(S.base==NULL)
: v$ s1 a0 A, |( H4 U8 ~+ d        {4 E: L1 `# X* Z/ o+ v+ W. O" \: F
            printf("动态分配内存失败!");
( o7 U& f( |2 K2 z, ?) s: O            return -1;. T4 i! }& l+ H1 Y5 U# Q$ n
        }
  k, ]* L9 U  D9 G' h6 W        S.top=S.base+S.size;
2 Y5 A4 u" ]# f  k6 ?        S.size+=APPEND_SIZE;
1 u4 U# K$ _7 d5 S- E1 }    }/ `% z8 c7 v, p. I! ]
    *S.top=e;; H! V1 g( E9 s, @8 [. c" g
    S.top++;4 M- p9 n" C# q# f  b
    return 0;
% v  B& v9 Q. h! k) `. Z2 b! Y}
5 D% x6 c2 H+ j  m7 ]+ F6 x( M  L5 x: L, |! `  u! F
int Pop(Stack &S,SNode &e)* k8 p/ a  U8 B
{
/ L+ o+ P+ X& G, r# x# T/ j2 s' D    if(S.top==S.base)
% Q# h9 i) a" m0 G' y4 }    {
% n& k# C/ }0 ?        printf("栈为空!");
4 U  P; |8 d! ]4 ?, x# y5 c7 R        return -1;- w* D' F; S/ L+ R3 Y
    }. O3 F3 a2 d$ \0 u
    e=*(S.top-1);$ ~* `: |) L2 e! s
    S.top--;
8 b' m4 M7 x8 z4 ^    return 0;
$ K  \3 u# p, T/ Q. p% X}5 w1 s, K0 ^5 A) S; I9 u

  R0 v4 I6 i: [) Achar get_precede(char s,char c)5 w/ d5 ~) u# |; Y; c7 `
{# `% W/ H& d9 h  h; ?: B
    switch(s)
8 \$ ]5 I5 b/ }* Y- |6 N* Y! ~8 u    {
' u9 y# `, W9 z: B" Z        case '+':                 ) n& n0 ^' x/ X0 d
        case '-':
3 N" ]: s8 p5 R4 |" |( A7 a% q             if(c=='+'||c=='-')% ~' S: P' K9 k, N2 r, w/ S0 t
                 return '>';+ j+ e  x: G+ w7 {! _
             else if(c=='*'||c=='/')1 d9 C- H, Z) z- T
                 return '<';( r" X: n; U+ M+ A% K# U7 q) C
             else if(c=='(')
  e8 i/ O" z0 k$ g$ Q1 ?                 return '<';
0 m$ z8 g7 s  i$ z' _             else if(c==')')) c8 Y4 t% \8 r8 G6 U5 g) D
                 return '>';
! h% A3 Y- m) _' E             else
! O( q$ I8 k& Z% U6 s& _                 return '>';! y8 _- {2 P6 ^
        case '*':
% R$ X! X& E+ f9 U        case '/':4 ?2 n1 l& Q" {# d$ o$ I
             if(c=='+'||c=='-')! L0 u; K/ }* \4 V7 J. I1 C% Y
                 return '>';: Y( S3 A5 l, B+ G% }* {
             else if(c=='*'||c=='/')
$ O; z  C7 r0 ^( K+ [                 return '>';
3 P5 I) Q' j% e! T+ c             else if(c=='(')
  }9 }# L" s6 C% d                 return '<';
6 Y6 m3 Z6 ?3 S             else if(c==')')7 T/ o8 ]; `, |" c7 y
                 return '>';
+ ~2 Z9 C) V! Q+ I             else- V/ y$ w  y# {/ Y9 [
                 return '>';9 W% p  y" i6 H: O% u
        case '(':
* w3 s5 ?6 `0 r" G             if(c=='+'||c=='-')" J  x# W9 S  ^2 R' W0 M) X6 G
                 return '<';
  }5 e" H' L7 Q1 `8 }, U7 L             else if(c=='*'||c=='/')
9 r. e. J+ S1 z  X* g5 ~                 return '<';
, a# k4 G4 Y* n: U             else if(c=='('). \9 v( u5 R+ F  @9 D
                 return '<';
1 a1 }/ e$ `8 {             else if(c==')')) i' I9 u8 m  u6 L9 L- J
                 return '=';
6 v+ {6 @0 ^+ e! Q             else2 d" ~$ V  V2 ^: ]
                 return 'E';
# u$ {! I/ ^. z: X9 ^        case ')':
$ M8 X& i  U. ^+ a  D# G             if(c=='+'||c=='-')& W0 s+ C9 t1 n/ s6 _0 A. \
                 return '>';3 S, j3 a3 R- t6 M: v0 r4 T
             else if(c=='*'||c=='/')1 r4 T+ G9 L3 R6 k& S
                 return '>';
, @$ t: F8 O* T, T+ }# i             else if(c=='('), K* ?. s7 s6 m& U( `, D5 H" \4 |
                 return 'E';+ x* Y( K( ?. G6 O: @" ~6 J& K
             else if(c==')')
/ S6 j# R& D4 V( F$ B9 N& i" p  c                 return '>';8 O% G, m9 Y* i  k' {- l, I* D, ^
             else5 [- @& P0 ]3 E* I! @8 X  H$ F
                 return '>';
2 Z/ P0 a  A/ Y# U9 ^* b- s3 ?        case '#':
- M* @6 |/ A$ Q" q, H2 X             if(c=='+'||c=='-')
, x8 R# N8 {2 U* V4 m$ h8 v2 i2 w                 return '<';1 s' c1 h8 X  m9 S3 X, e
             else if(c=='*'||c=='/')
3 S. L; o. {9 U                 return '<';  y- u0 V0 T- F6 J2 W
             else if(c=='(')$ }2 g" x- B0 T/ F* _1 B
                 return '<';0 m# w8 u4 l) L* E3 G' D" y# ?
             else if(c==')'): J0 N, {. P. E( P
                 return 'E';, ^) R; Z! L. r3 h7 z; U
             else, ]: w  }. e2 I% ?/ ?( F' H
                 return '=';
) }& H7 e% m. B! Q! M" X        default:
' q0 a+ r( _  d% H  e& N: `             break;! ^4 x& }4 W  m/ Q1 t' d
    }1 e4 A/ P/ g* a% B% Q
    return 0;   
! \; s" T# i5 E; h! h- B}* i$ ~# O# X7 n. N! Q5 w7 B

- S) N$ W0 Q9 m: ~% @$ `int isOpr(char c)
9 A& Z( c/ s$ [; U{
. p  K* G& t, S3 ~4 x    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
9 D5 R, J6 _% H: c' r8 m        return 0;9 k. z/ b5 e# T( v, u  J2 T7 m
    else : ~8 b. i; y) B& R
        return 1;
$ G& L: X# t. }0 S, {}
1 r) _! u8 Z2 M2 M! m
0 \- }. {5 ?$ s+ r% Bfloat operate(float x, char opr, float y)
( R/ z  ?6 ]+ ^2 V4 ?{
; H5 A: q6 W& \6 \; N    float result;3 e; [9 k; ~( s& t6 Z& ?
    switch (opr)
+ v; I5 r( }6 j6 T( O) t8 i    {
4 U$ z7 R" e2 r5 P8 F6 \" `        case '+': & ^+ i: `5 Y; @" ?8 _3 x* A
             result = x + y;
; }' Q% B, [/ C3 H, R             break;
* G7 W9 l& p! W* Q( m/ h# Z9 Q. |        case '-':
- ^% E. h; y! V             result = x - y;
0 S) Q) Z/ J+ L, c  y             break;
3 [- K* }, `( x& D- S7 V/ \        case '*':
1 f3 }# [8 L* m8 k% i             result = x * y;( J6 j( K; c% G6 x# v/ s
             break;
& l! {8 c' m+ T0 t        case '/':
* v1 }8 Q4 e  t+ k             if (y == 0)
- \7 `4 \( a* u- ~+ r( h9 {             {, P) O0 \: K2 a
                printf("Divided by zero!\n");
& ~$ B' m* ?( d- \                return 0;
! ^1 o, C& p9 }9 E& A  x             }
$ \# _/ y2 ~& V8 {2 U9 A8 w0 T             else. Q# h$ m" ^9 A* v2 A
             {% _, U+ L( I' C9 T: ]: r
                 result = x / y;4 ~7 l+ M& z8 f( y  A4 w% G
                 break;
5 s6 P- f* Y8 m& G9 o$ r( t4 u' w3 Y             }
& ~# V9 M9 f1 [! g8 f. k" f       default:
# J% s9 m9 k9 i+ n9 _, ^             printf("Bad Input.\n"); 9 x$ L4 y% u5 T/ E1 N0 o
             return 0;1 r" M% b! o; m) @9 ~3 r4 c9 x
    }2 i  x7 q, o5 J* Q  ?
    return result;
0 O2 G. n3 ?7 J}    6 W4 J* q8 E' |& @/ c1 Y8 Y
( q; B( m. y& j, y2 M5 ~# q, m2 @2 N
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/3 e" q9 s8 q6 O- {9 n$ e7 r
{
+ W+ t# m+ Q* x8 l1 T    Stack optr,opnd;$ V0 W2 x" ~) Q. A# @2 b
    struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;8 z$ N' Q! I. J/ W
    char c;
1 T, I' W4 N# u; O8 |7 n    char buf[16];
! C8 F+ I" I% j. A% J9 j, x    int i=0;
  H) ^, H5 C% n1 Q- R    - @8 v. }% [2 C8 ?0 ]2 k
    InitStack(optr); /*用于寄存运算符*/
, O1 y$ a) v+ ?0 c5 f$ Y    InitStack(opnd); /*用于寄存操作数和计算结果*/. y- g* H7 i  c2 y4 `
    memset(buf,0,sizeof(buf));
9 `& [0 G5 d. R: i    8 i6 F; a: u7 O% y
    printf("Enter your expression:");
4 Z1 F9 M; h& {. o, ?  l# @# {        
4 ?( e" Y" B6 d0 U, I    opr_in.ch='#';
0 _; C7 _$ }$ Z6 W( @3 @! E    Push(optr,opr_in); /*'#'入栈*/
2 r1 C) A% r& u2 ]1 r2 X    GetTop(optr,opr_top);+ ^0 y9 d+ g' I% k5 G
    c=getchar();
7 k3 z1 z, e! A+ v) y: P5 r8 X! N' V    while(c!='='||opr_top.ch!='#')
* ]8 E/ w9 g* s/ ]- b    {. r% ?- g! o2 }
        if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/$ q5 o5 Y; |& M5 F1 [/ Y
        {$ F, N0 q6 `# a& m' Y
            buf=c;
) p) @# {; ~9 k- }' P' l# `            i++;
) y2 U, A) J; u2 D% b+ b            c=getchar();* x6 A, S3 m0 m
        }" {  b: w, r" P, `6 h
        else /*是运算符*/
* J. G) r) Y1 m( g) s        {
/ f8 I2 x* e6 O1 b: w2 n5 ^. k" }+ B            buf='\0';
" I" V* V3 z9 a; o: d9 N            if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/& ]; `  K+ e: k! v& _7 x
            {- [. J0 o$ g2 z8 [. P" n" Y
                 opn_in.data=(float)atof(buf);
8 f& V* L) E7 w) W8 o# r                 Push(opnd,opn_in);
! U3 F, t5 o  f1 q( V/ G/ Q                 printf("opnd入栈:[%f]\n",opn_in.data);- e4 g! @* o( a
                 i=0;
+ v8 o8 {' q9 g  |6 {, c                 memset(buf,0,sizeof(buf));7 Q2 h; r# \' _* S
            }2 p9 ?' {% K- ^  d
            opr_in.ch=c;- {# T& m- Z  b. |0 a0 j
            switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/) B- M8 H& p- t, Q4 K  E
            {9 g$ k. q: ]- D/ {
                case '<': /*优先级小于栈顶结点,则运算符入栈*/: k/ |3 K4 x  W3 `2 t7 V, Y4 V! M
                     Push(optr,opr_in);; i+ z+ Q! K. @: C  e: b
                     printf("optr入栈:[%c]\n",opr_in.ch);( r! L+ M( l$ z5 X. }. P% d
                     c=getchar();
4 O( ^3 {) F, q$ F' }$ {                     break;
$ c" g' G- n4 D" ]4 o6 F+ r; Q' V- _# H                case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/5 T7 `5 F" Z+ O
                     Pop(optr,e);' c& k7 U4 B8 B3 U8 N' l* }
                     printf("optr出栈:去掉括号\n");, _) A! Y$ h2 B- ~3 G$ q* t
                     c=getchar();4 Z: e9 ^$ y2 |7 S0 I/ r" t
                     break;
0 H9 k7 Y0 G; E; Z% A  ?& C                case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/, K/ {9 x  T7 {3 y: d" J0 G
                     Pop(optr,opr_t);  Q& n( v/ Q" H- v# }+ `
                     printf("optr出栈:[%c]\n",opr_t.ch);
/ w" R7 V, C+ B4 C( J4 ^- J: G                     if(Pop(opnd,b)<0)2 G8 @6 d4 f7 v8 H, ]
                     {' A- u6 }( M0 G
                         printf("Bad Input!\n");7 ^: q6 H* s. D1 E: z  Q: W) N
                         fflush(stdin);) u  ]" V& w. Z0 p$ `! `
                         return -1;# h: @! {1 }& H& z, q$ S2 [. l
                     }
0 T) a% A+ |+ Q# w3 {7 T                     printf("opnd出栈:[%f]\n",b.data);
( {0 n# P) V9 V2 B' y. S3 \1 Y* _; x                     if(Pop(opnd,a)<0)
+ C3 I$ D9 B) P: Z  k4 v) R5 C                     {* u" h. G; R* ~, d5 A
                         printf("Bad Input!\n");! S$ S$ ?  q$ P$ V  x2 [: X& T7 f
                         fflush(stdin);& W: j) B1 X' W, q% y7 I5 M
                         return -1;
  t! ]6 V3 o/ [' l0 V                     }2 C- l4 j, N) B4 o
                     printf("opnd出栈:[%f]\n",a.data);1 |0 Q6 n3 `# Z8 Z5 m
                     opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
3 }) b! h: d1 r. X% ?+ t                     Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/; v$ _3 y) ~: \0 x6 Y% a) G
                     printf("结果入栈:[%f]\n",opn_tmp.data);
( y& A' V7 Y3 @4 R2 H) t( u6 z0 G                     break;1 E$ D. C+ v! `' E  Y/ `
            }. i4 G$ p7 X3 \7 }/ T( p5 `; |
        }
( V7 j0 V) T6 }% f# E7 e: ?, |        GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/               
! V7 i; z" _! P* k7 J. e6 E    }
# {* |+ _- f, `    GetTop(opnd,opn_tmp);/ S0 N* H7 T' d0 C' A. T  \/ W
    DestroyStack(optr);
! P6 W# ~0 c+ b5 |" f    DestroyStack(opnd);
' O2 F# P% S0 \- i) ^    return opn_tmp.data;
, t: u( L+ I/ x4 N}/ v, G; M) f3 S! J" U
) n4 s% {0 b( |; W
char *killzero(char *res,float result)! s8 m1 x" G7 h) y- x
{6 @' U5 }; w: v7 s9 O: h8 d' j
    int i;# i! w( V- g/ V7 o* o
$ w0 c) ?8 R" o* J6 T1 }2 h; d& Z
    sprintf(res,"%f",result);2 @: |  b( p3 Q* W* t" k0 ]! g9 H
    i=(int)strlen(res)-1;
" z7 j* _) N' }    while(i&&res=='0')
  U6 B, [$ j: b2 l- f- q1 `) f    {7 T! t0 Q" _. q
        res='\0';* b  ^9 p( h+ B- T8 r* z* W
        i--;- V; r3 y$ ]# g) B% b/ f
    }$ F1 w% V9 I- c' ?; ]' `0 Z! U
    if(res=='.')- q( W& I# i! j  I! ?
        res='\0';- r' b8 F& a( q2 _
    return res;
& I% ]: B; V$ i* v: n}
* X$ g( i$ ]) @5 g8 |: o. Y4 J2 G, C
int main()
* Y5 t% z# a0 t" |/ \6 j  |0 r{
0 v" Y8 W9 J' q    char ch;
. x4 ^5 ^5 P! M! s, y$ d1 w    char res[64];6 I  y5 ]2 D4 s8 p# J" Z$ }
    float result;$ }0 ?. R1 s$ t, l  t% ]
    while(1)/ A1 _5 `7 f. f: V9 m8 \
    {! j* f0 {' T7 Y" l; L: F3 a) G! J0 W
        result=compute();$ R# j, j8 U2 A; k
        printf("\nThe result is:%s\n",killzero(res,result));) ^/ j- \: ?& N2 j8 b9 k
        printf("Do you want to continue(y/n)?:") ;
. S1 l0 U1 _$ a" B' p+ a        ch=getch();" r* P+ T0 G& ~4 c
        putchar(ch);
( X7 T! T2 x( \# L% f        if(ch=='n'||ch=='N')  @; V" M0 X5 b; J9 ]% b. X
            break;
; @  B! I9 C  S' c0 ?. D        else* n( o2 [/ B* e9 |% J
            system("cls");
  m3 B9 Z$ n2 L; Q, H    }
: K- q+ \1 L( k" B/ P2 a/ x    return 0;0 y" r7 C$ o! E% D! R5 J% `& G! }
}
$ O1 `; y5 q5 `# J: f. I

- ]% c' B$ e) P# K* ~/ p[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

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