C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的., P( q- I9 y1 H2 I5 V8 T
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=4 P, f, j+ R7 ~! H
/**************表达式计算器************/9 d& m& N9 V& L$ s: I
#include <stdio.h>' c3 u) t' ]. u4 h  v
#include <stdlib.h>
#include <string.h>, c8 \2 Q9 T1 Z# a
#include <conio.h>
#include <malloc.h>3 B) i! [5 u" g; w( X3 y9 \" a
) i5 L) E; ~2 d$ o
#define STACK_SIZE 100* U2 n* ?2 N' |/ w
#define APPEND_SIZE 10
% o7 v1 a& E# f- t0 M( y/ F
struct SNode{: G4 O9 h: Q+ w2 i. `
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};& x9 K$ l2 v2 r) q- @: S+ C

struct Stack{
SNode *top;
SNode *base;
int size;# S) a& k* l9 C! D( A4 z5 K. ^
};
/ k; I2 P1 C% S( I3 _' a# p
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/* t/ K7 l& ^# `! T% L' t
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/5 j6 a7 C3 U& _
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/( `$ M! l2 u* }6 w
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
0 B9 h% u# G) \3 a' a
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/* v7 R: a! J2 m" V
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/$ d' G: q9 Q9 p; {! M& i6 f$ S
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/- z" e6 u; [0 h' X# u( R
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)2 A; D0 f! J! K1 ^! Q1 k# |# ]8 W
{
      printf("动态分配内存失败!");
      return -1;) z7 N# S' }, [6 ?1 b
}9 ^# J- I& p2 Z
S.top=S.base;9 S4 K+ w# {9 V) u1 Q
S.size=STACK_SIZE;8 r- K1 {0 U: ?& t2 X
return 0;
}9 V. t3 Y3 k7 Y7 @  I
7 v  i, n4 e$ A% M0 Z+ J$ H; X9 u
int DestroyStack(Stack &S)3 g' ~. c% v2 v9 M
{: O; w  _& }: T. X- [# |
free(S.base);
return 0;
}# e# _; ]& M+ k: E

int ClearStack(Stack &S)' U* u+ G: V  d. K: l
{+ \3 j5 Y- {% @2 U  T
S.top=S.base;6 E1 D9 y- t/ M6 Y2 s8 F
return 0;
}& V& K. D6 t* L. z0 T' ?5 R5 A
8 c" {3 ^3 S% |# q) z" ?! Q
int GetTop(Stack S,SNode &e)1 Y& n" y/ K, X
{1 f) [7 f+ Z. g" d7 S
if(S.top==S.base)2 R( Z6 J* T7 r+ ^: t  b
{5 K, t: e# h/ Y% X; T! \, x& U
      printf("栈以为空!");
      return -1;/ C: D" g& x# T' Q: T" U
}) E0 j; v- k$ Y3 b
e=*(S.top-1);' G" @; T3 I6 _5 o9 q% z6 I+ c
return 0;2 r# A" s2 F8 u! C  M$ s8 _1 O
}
: h7 {& Y! L  ?
int Push(Stack &S,SNode e): ?  x  d+ @1 I) a% P# p* _
{
if(S.top-S.base>=S.size)
{) m" U5 |1 W  B; w; ?* M+ s7 q: g
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");7 M* T  }2 r% c- a9 d
         return -1;& w$ O/ O6 y+ V1 @9 ]; ]' E) b
      }; F+ {4 |. z6 W5 X
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;% g5 B3 E- Z/ z; ?% Y& E
}; X9 S- _, b0 l" Y& M
*S.top=e;
S.top++;9 U# t" N% q* s1 a9 _2 t& D
return 0;2 _& P$ P9 F3 P  _6 v0 a
}

int Pop(Stack &S,SNode &e)7 [! H5 H* w$ M) q- `
{
if(S.top==S.base)
{/ t8 l1 K: f) p/ R! A
      printf("栈为空!");1 m1 E4 v6 R+ j9 T5 d3 c
      return -1;, m, n$ {% u7 K! G9 @/ j8 e
}
e=*(S.top-1);
S.top--;% {- J* }8 ]' [  F% R* {
return 0;- I' U0 v* v7 I6 ~* z
}
% q; x! O5 U4 ]" \
char get_precede(char s,char c); a# Q9 Q( V+ t
{/ M+ j  R/ i1 M$ x! M: e% r. k
switch(s)
{$ R" n) L; V1 C! ~, V
      case '+':                , }' l6 C$ ~. i8 h' R0 r
      case '-':2 ?% l& Q: |/ F" p3 V0 _9 P2 g* l
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')& W# o+ R- a! ?) q
               return '<';
         else if(c==')'): X$ e( i. z9 a, g; O* f6 j, C2 `
               return '>';
         else 0 z8 i9 W# y7 c9 O
               return '>';/ F! Q/ h4 ], g8 g: N
      case '*':
      case '/':1 h( T; y  L- i1 z4 S& H5 }' ~( r# U- C
         if(c=='+'||c=='-')% j5 b5 J0 F* j; [; U9 G( P
               return '>';: o0 A9 j( s- p. B# c: E* ~
         else if(c=='*'||c=='/')8 i' h0 i( ?' N# y' `6 v- i0 ~6 V
               return '>';& E! d, J8 s+ k& n6 l  ~# f8 N) |
         else if(c=='(')
               return '<';
         else if(c==')')2 V. }$ x: P; Q2 K! }+ |
               return '>';2 q9 {! x. K& h: q6 b
         else
               return '>';
      case '(':* c" O; q1 R% x* q7 f
         if(c=='+'||c=='-')
               return '<';+ j' o+ }0 y; Z, E! I2 w
         else if(c=='*'||c=='/')9 U$ }+ Y& \9 C; O# `6 J0 z) w
               return '<';
         else if(c=='(')- `- ^  N% C* L/ d8 J8 N$ ~
               return '<';
         else if(c==')')
               return '=';4 b1 V) R  R) W. i5 M- f; Q8 l; _
         else
               return 'E';! @0 B2 B& s. h  u- O; s
      case ')':% ?+ W7 c9 e* f+ I7 S
         if(c=='+'||c=='-')
               return '>';1 E  k5 J5 e4 @; {% T
         else if(c=='*'||c=='/')
               return '>';8 }* X; s& F2 j  h4 Q
         else if(c=='('): o/ l6 T* c4 `- n6 j- G. e
               return 'E';+ q" e. [  W/ a: c
         else if(c==')')* n: o5 Q; V% K) \5 ]2 X  c7 p" w
               return '>';1 K/ \6 D$ M1 @3 X$ w
         else1 G4 L4 ?0 r4 A  _4 m
               return '>';/ l6 @: c# R1 M" p  E
      case '#':; S* U: {. M3 V. Q2 h6 b5 N" O
         if(c=='+'||c=='-')6 _; d5 Y% o0 T0 S& {. K
               return '<';: I' k, j8 t5 i8 \8 Z/ ]
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')% z' L% u" h* l3 s& E. S' A1 _
               return '<';% T7 }: ]0 f) i1 v' Q8 k
         else if(c==')')
               return 'E';8 S  J: ~" z* E: r. G
         else, D' s6 Z5 r) I! ?! F- t
               return '=';
      default:& ^- Q6 U$ C2 M) f1 Z3 m
         break;
}
return 0; 1 W. s8 o2 A( ]% V/ {8 R2 _
}2 M$ M; S' h) J6 N

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;) n6 ~- r6 I8 E- L  r
}
, }4 j. f4 t- M0 ^
float operate(float x, char opr, float y)
{
float result;6 L% X& A4 y# U/ r, b4 R& [1 j
switch (opr)
{3 a: \2 E6 F  d& S; d4 v+ R
      case '+': / R4 M, G5 X# V( p2 q1 A# y5 W' q2 G
         result = x + y;3 [% e! S3 ]2 B& L% y
         break;
      case '-':   [) g0 v9 Z  p+ _2 d
         result = x - y;
         break;2 v. C# k* R1 l& T
      case '*':
         result = x * y;
         break;
      case '/':
         if (y == 0)
         {3 a, x1 N) B1 q! L/ {
            printf("Divided by zero!\n");5 g% f( `% X; {0 R5 N) x' a& h
            return 0;
         }
         else  T$ c3 T, d& B6 \5 K; Y
         {
               result = x / y;
               break;0 A4 s& Q/ {: s% h+ \
         }0 i* _* M) a+ x2 s% u, z* Y1 p$ s" C
   default: 1 v. e' t' F+ R& r' j
         printf("Bad Input.\n"); - V7 M% L4 V* \5 z) H3 r: R
         return 0;
}7 {4 H9 U/ i6 t( X
return result;1 U; P; F6 E& |: ], E  \
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{+ F5 \7 C# x; u5 O) ]# @
Stack optr,opnd;0 @2 S4 L: T6 q* C+ E& Y" H' P9 X
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];& O$ f7 G+ M+ g$ d+ d
int i=0;

InitStack(optr); /*用于寄存运算符*/. E+ F/ W0 U+ Y: m
InitStack(opnd); /*用于寄存操作数和计算结果*/% n- k, h5 R/ O) G$ J
memset(buf,0,sizeof(buf));% @4 U  s  R& ]# E, m* X
6 |5 u! _1 E( ?% Y
printf("Enter your expression:");
      * z' H) Z+ Q" w* \8 u
opr_in.ch='#';) o1 @; ]. k( K3 z9 w
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);* Z0 T3 u  U: K5 S. ~- y% N% H
c=getchar();  \# t! e8 X' U/ T; a  Z
while(c!='='||opr_top.ch!='#')+ S9 }; J" n1 M
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*// L9 K. n" W$ x" X% |2 T. r
      {
         buf=c;5 Y7 [& p* x1 C3 Y4 F; L
         i++;8 [8 {' y, t2 }6 _
         c=getchar();
& k9 M8 G0 E! j! \6 |       }) ]. M- u" t- g# V* T- p) c% p
      else /*是运算符*/$ x( I: e( }5 i0 p- q- X0 A! w
      {# d9 p) Q, |  [' L- u5 Z
         buf='\0';
0 F; [, W3 p$ J          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/* {* d+ H- ~* J2 G2 q+ K+ R3 u
         {
2 R. o  j) U* [$ Z9 m7 w2 j& H+ I                opn_in.data=(float)atof(buf);6 l: T3 O7 e6 p3 Z
               Push(opnd,opn_in);8 [7 k8 A* g6 A0 ?
               printf("opnd入栈:[%f]\n",opn_in.data);5 q) O( o+ |; y7 \
               i=0;
' l5 u  x3 K3 J9 m- O7 T: r                memset(buf,0,sizeof(buf));
+ y  n* b5 C8 ^8 U% [7 |' ^$ w          }% X6 C* q! ?7 j! t6 T; z2 P( x
         opr_in.ch=c;2 F) m* B' h* r) ]' Z$ @# X
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
" g- N0 [' ?# J          {1 w+ A* z" ^. g& _( D8 i8 Q
            case '<': /*优先级小于栈顶结点,则运算符入栈*/' [6 H1 w6 E$ B4 t+ s
                  Push(optr,opr_in);
" q$ s, C$ u: _$ p6 K- y' e8 O, Y                   printf("optr入栈:[%c]\n",opr_in.ch);4 [4 N/ S  t3 z! N+ b
                  c=getchar();1 i$ S/ x: ]4 U2 w4 F% \, J
                  break;' x0 |* Q- u/ f+ t' g
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/$ Z2 d$ E+ ]& y+ p: x
                  Pop(optr,e);
% X9 i+ h/ m0 R0 s( s                   printf("optr出栈:去掉括号\n");+ g$ E/ E: V% }7 a( X
                  c=getchar();
0 L. M) b/ E1 j; C+ k                   break;
" u. |4 A8 [! K7 W) ]             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
% h8 t+ K7 ~$ ?7 P                   Pop(optr,opr_t);
6 P5 m" I% C; v% }) _                   printf("optr出栈:[%c]\n",opr_t.ch);. U- ?* J1 I9 b# c$ u: M# z3 ~
                  if(Pop(opnd,b)<0)
# ]4 n$ ~6 j' r                   {
; w& E8 D4 }( I" p5 d/ n* ^: T                      printf("Bad Input!\n");
: b' A2 C7 I- X                      fflush(stdin);
/ J' b% ?# V3 j                      return -1;& h; q9 ^! l* |: z! z8 n
                  }8 E2 y' n5 Y9 [) H, P8 u
                  printf("opnd出栈:[%f]\n",b.data);4 l  b8 q) \6 A# [1 K$ |! @1 N6 n" K7 s
                  if(Pop(opnd,a)<0)
- C0 Z; B, s  ^9 Z  b3 ^                   {
! S  |% U& I7 h2 j- x) I2 R                      printf("Bad Input!\n");# Y2 S3 H( o' g2 l" M  |9 i
                     fflush(stdin);
0 \- k1 t7 [- B- e# S' y* F                      return -1;2 O2 M: b! A1 T! c  R* T
                  }
8 t/ q+ F6 w) W% {- {0 I! l* y                   printf("opnd出栈:[%f]\n",a.data);0 m. Z1 O" w' M% O' S1 ~& |. T& H
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
! V+ x! {8 F% z! O6 V  W- ^  \                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
4 Z% g; U9 l% m) k8 Y                   printf("结果入栈:[%f]\n",opn_tmp.data);
9 N+ P/ h) z% V3 ]+ S1 R                   break;
2 R' q7 g2 V$ ^" a7 N+ m( J          }
, M( t( P. A( c) I0 n       }
, y) V5 ?/ `; A) H# x       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
/ d5 S2 @0 j' y }4 U" U  f+ c1 b1 U
GetTop(opnd,opn_tmp);3 n5 ]3 y( R1 X# }$ C
DestroyStack(optr);) E) U; |2 H& K& B/ _. Q4 b
DestroyStack(opnd);7 m& {# C. z; ]
return opn_tmp.data;) V* s, {- E+ ]/ j4 N; c6 {
}9 b; n2 |% s3 b: Y/ z: c5 ]+ }

6 @6 K4 c7 ?$ o+ Z4 Fchar *killzero(char *res,float result)
, f: E/ n- i( L4 |$ S{
& \* B5 F4 K7 [ int i;
  o/ Y( J+ ~; I( }' {3 w# L  g5 J6 X7 [  v4 D" S8 _
sprintf(res,"%f",result);9 E, Q2 L: p0 P6 Z" e8 m8 H! T1 i# m
i=(int)strlen(res)-1;5 a" G: Y1 J( Q" `- b" c! j
while(i&&res=='0')
8 H$ `; J$ }4 g; h0 p* |( {' c( ]8 ] {
3 R8 W* p# ?- H% H4 Y       res='\0';: o$ T4 F, H) A% }
      i--;5 Y' U: Z% [8 u, R8 }  V
}) E, I; V: L1 N, U
if(res=='.')% e; q) X& V4 l
      res='\0';
6 `8 F) {" {- n return res;9 [  s9 P+ W- ^" X" U
}
% ^$ ]+ k, x8 H  S
! i+ I9 N/ A4 a2 lint main()
+ m# R; A! V* Z{% i* h) _% c7 Y5 ]
char ch;/ H& q: f9 m" L  _6 X7 a
char res[64];7 n9 I$ W1 G( S* R. i/ U; m
float result;
/ G7 y2 l2 F! S while(1)! ]3 K( l7 s+ R
{
/ F/ U! c: y! ]! J% k       result=compute();. J- M" p2 [" H
      printf("\nThe result is:%s\n",killzero(res,result));
* I$ m! \4 _* A       printf("Do you want to continue(y/n)?:") ;
; L* V3 A9 q# B; y/ r* Y       ch=getch();! U( p2 y! c0 q6 H0 @, q
      putchar(ch);4 a1 P# A1 d6 y) }( G  i2 Z- b. f
      if(ch=='n'||ch=='N')
- b# z* b4 G1 ^* `$ j; k! W; v% {          break;0 x* g8 E  S' D' m+ H# g
      else
% c, {  g* _/ `3 L0 c          system("cls");/ ?1 @. W* j! E% r- K
}
* u% U' i2 a3 j& f1 m return 0;
( u& ~6 E2 L( e0 v# O! ^! Q# g}  H3 |# u- @  `7 }0 q; i* p2 O/ U

[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

[收藏此主题] [关注此主题的新回复]

[通过 QQ、MSN 分享给朋友]