C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=4 ?7 s( ?; n% R6 e
/**************表达式计算器************/# g0 D; ~0 c3 W, _
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>. b. x9 Z; K* w! V! B
#include <malloc.h>

#define STACK_SIZE 100
#define APPEND_SIZE 10, m! A7 P0 X6 D4 p4 Z

struct SNode{
float data; /*存放操作数或者计算结果*/( k% }$ ]+ x  g
char ch; /*存放运算符*/+ `2 e- K$ W! h& c0 o+ v% g
};8 ?' C: o' Z; w+ _3 G+ E- O

struct Stack{
SNode *top;
SNode *base;
int size;
};, o2 l; [5 m  o9 C' U
" ^1 L$ w7 a5 Q9 f2 f* v
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/4 ?7 e# `( D/ X0 A* ?$ j' u& G4 _
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/; t; @* Y! B7 [2 I
int Push(Stack &S,SNode e); /*将结点e压入栈*/* @- u6 F+ s; k1 Y! S' J
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
* `  S. N9 k9 J3 [' X! z; L# `; ^
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/0 Y, d; w8 k: z) Y& m9 |$ r9 I
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
) G2 B2 g$ o1 c' _
int InitStack(Stack &S)5 @) Q7 M* l6 i+ q
{3 E3 e+ A. Z, Z
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;$ o# y4 v% G# I, d
return 0;
}
6 d: `1 Z9 A# ?( `1 {3 K. V7 [) x
int DestroyStack(Stack &S)3 B) {; w! p; B+ g
{1 u* U9 N- g/ ~7 W) x! V
free(S.base);
return 0;# _/ J* R. Z$ o. ]) y( w- k
}
$ [5 ?2 A5 Y' p0 y
int ClearStack(Stack &S)
{/ u1 ?) f: p4 l0 J9 Y8 u
S.top=S.base;
return 0;
}

int GetTop(Stack S,SNode &e)
{0 k7 C: ?+ \2 t4 _' g5 y0 ]. _
if(S.top==S.base)
{' B, S8 v" t  f4 j% H/ s! w0 o  `
      printf("栈以为空!");
      return -1;- f! n, k" M) c3 I0 W
}4 e6 t2 q; b# Y- x
e=*(S.top-1);! T! e9 h" [( F8 X
return 0;7 }5 w% ~9 B. I5 X6 M5 y) {' {: U9 C
}
5 |6 e. @+ G% A- \3 R
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{: z+ p6 v7 b! ^: G0 a
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));) S3 o5 w% k6 ?2 l
      if(S.base==NULL)! |* ]0 E2 A; G2 E9 F+ h
      {
         printf("动态分配内存失败!");5 M6 g, r8 v9 w2 f1 ?6 O  b! {
         return -1;
      }
      S.top=S.base+S.size;- ~- X) E3 Z+ w% W
      S.size+=APPEND_SIZE;% K! o" N+ s: M  g) P  Q
}0 h# k) t) S; J; K( z' A6 t
*S.top=e;. w& O- z5 C# P- X/ z
S.top++;
return 0;
}! v1 W2 ?+ P; `- a8 i4 `

int Pop(Stack &S,SNode &e)4 q% M6 |7 r8 X* x
{
if(S.top==S.base)
{
      printf("栈为空!");8 K4 @# o. S% n4 b8 ^( I' f$ W
      return -1;
}- n, N! P% A. E
e=*(S.top-1);. x6 N; _3 |: @+ {6 _: ?$ t9 z
S.top--;
return 0;
}

char get_precede(char s,char c)
{
switch(s)" T7 Q" j7 w3 n. A9 L+ u
{. ~5 u6 Y- W# p* k% e
      case '+':
      case '-':' K* B  m% M4 E  ]! m
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')" O; N) G6 b4 B. i( e" r
               return '<';' \6 Z$ A& u+ D% F& U% Z4 c& s- f
         else if(c=='(')9 s) i$ B0 u9 r
               return '<';
         else if(c==')'): l% G+ T6 s; w& j$ d1 _
               return '>';6 Q& p: t. i8 H, r% `. b
         else $ y- y: s" x4 O/ n, M9 B
               return '>';
      case '*':0 x: o% p: O7 I( ~4 U5 B$ [! W  U! s
      case '/':
         if(c=='+'||c=='-')
               return '>';$ u& _5 Z/ `$ I* Z8 l% m1 _* [
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')$ z4 K4 W: S. b) p7 q4 L
               return '>';4 e5 w/ U- S( S6 W
         else$ Y: T* k' x7 u3 o3 Q8 ^
               return '>';
      case '(':* k. q/ z( J: y$ C( }
         if(c=='+'||c=='-')
               return '<';( m5 h$ l& a% w- O' m7 U, m
         else if(c=='*'||c=='/'); T7 ^) e. [, P
               return '<';7 P% d) f( R$ U( e
         else if(c=='(')
               return '<';
         else if(c==')')# F5 V1 y& J7 L1 G0 L
               return '=';
         else1 E+ [  I$ y* i& T0 H: o: a/ c
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';7 o- v( o( Y- A) x5 t! [
         else if(c=='(')# {( t; [& Z$ f, j
               return 'E';
         else if(c==')'): J' O; m; C) j! C% {/ X
               return '>';! D$ R) ~# b& W* r  [- x. a
         else' y9 l( s& s- L/ A* p! ^
               return '>';
      case '#':
         if(c=='+'||c=='-')6 _  M9 K' h4 d& p5 ^: B
               return '<';' p+ S$ z- t! l7 g
         else if(c=='*'||c=='/')9 C4 t6 i9 P% ?" i$ |( X6 r* D2 I
               return '<';
         else if(c=='(')
               return '<';+ r9 w8 ^) u5 e2 v! f
         else if(c==')')1 h- r2 H0 `: e, `/ b+ Z- Z$ V* ?6 F
               return 'E';
         else
               return '=';0 v5 ~4 u; V' F3 E% ?( f5 F: h
      default:, y4 e9 t/ ~- P! x" T- s
         break;4 c% h' t+ Y" l
}
return 0; + Y; X/ C. B  J2 ]9 u9 f- s
}" e2 i  X# ]5 i' [$ v
' A2 [. O) ]# ^  M7 O% E
int isOpr(char c)  V7 P; w' g4 e" j
{  E7 J2 q3 V! f. m+ ?! ?  `+ s
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')7 O% ]! ^; v1 Y% u( T5 Y
      return 0;
else : C: q* f% w/ y
      return 1;4 z4 s$ t6 I6 Q1 j  b
}+ c  ^' W3 P1 |/ a# [% m" t

float operate(float x, char opr, float y)" b  o4 |6 w. M: @! }& }
{
float result;
switch (opr)
{+ ?- b( [8 O5 ~, \
      case '+':
         result = x + y;
         break;7 n& C* M8 O& X/ r
      case '-': 6 Y2 J+ T& y4 m
         result = x - y;5 A+ Q) H4 H* E  i' M( L
         break;. U- j. W) d. Q! r5 h' O
      case '*': 1 u* V5 n2 n# g0 C: l; {/ ]
         result = x * y;
         break;
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;
         }2 L$ b9 [# y$ z! }
         else
         {
               result = x / y;) i0 Q7 S( F6 o5 n, U/ c  l( g
               break;
         }9 t" {. O* j% a3 M! D- q
   default: & r/ W' h/ `! P& s/ g$ g* _! v
         printf("Bad Input.\n");   e. u) Z# M+ _9 e. e6 V. M
         return 0;
}
return result;
}
8 w6 e" c; B5 q1 W
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;% c5 w8 E7 ~4 [7 X
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;! ?9 ?  C* v" N/ M7 b& C# S
char c;6 L$ G" Z4 p. P7 }# r( m/ W
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/' _/ a/ J7 e. _0 J
InitStack(opnd); /*用于寄存操作数和计算结果*/3 i4 Y5 x8 j( H# b
memset(buf,0,sizeof(buf));

printf("Enter your expression:");' h* R0 j7 V) M  ~: l

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/( L0 s- \5 E. z) j% g8 Q3 `
GetTop(optr,opr_top);  F" g! T: P6 G* q
c=getchar();6 X+ h* p7 P  j! `9 ~* I, p. f* J
while(c!='='||opr_top.ch!='#')
{6 \, s% C4 O; i" u
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {3 V; y. S. T# R( U2 J
         buf=c;" r* t) _  Z' ~' q  H# q
         i++;
0 ^/ i5 {$ m, _+ M          c=getchar();
4 \% }3 x% R; u4 ?2 |2 R       }
% Y/ t, u( @& U( J# c% u       else /*是运算符*/
: y% R% x8 I; i7 _9 g, m       {/ H6 u  j+ M7 g  e9 ]
         buf='\0';* ?5 `+ G4 F% g0 I' p( [
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/3 Z8 C4 E) j3 \1 W/ Z5 O
         {7 z! w; T/ Z( N- v5 F* e
               opn_in.data=(float)atof(buf);
6 J7 m. ]5 E* D0 O+ I/ w  ~" Z7 Q& T                Push(opnd,opn_in);" L# o; t- ~2 H. P' R
               printf("opnd入栈:[%f]\n",opn_in.data);
& ~4 S2 a4 w5 o6 F$ U                i=0;; D  W. s2 _% E
               memset(buf,0,sizeof(buf));6 Z- T5 d' K/ a
         }$ F$ r6 k$ T, i; l7 y( L9 _
         opr_in.ch=c;
5 U: |) o: _+ Q# A5 U2 l6 u# |          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/8 i" v7 b. E; `
         {
$ m7 J; w+ @3 J$ I* I) G             case '<': /*优先级小于栈顶结点,则运算符入栈*/
# w! Y, o* I3 \8 S$ q                   Push(optr,opr_in);. q( P+ N8 l8 h: T# i1 U% j& V
                  printf("optr入栈:[%c]\n",opr_in.ch);. A7 W" ~  X  w/ x2 x: V+ R! {
                  c=getchar();) j& F& F/ t4 e8 i- t/ G7 S1 o
                  break;) ^! Q; k4 q0 e! B1 v8 [: {
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/( Z) B+ t8 ?% ?  q, L
                  Pop(optr,e);3 t; G0 w3 t7 @  a8 q, I
                  printf("optr出栈:去掉括号\n");
. ^& z0 k8 p! o# s' f                   c=getchar();& ]$ h7 p& ?, z
                  break;. u! o' C1 ?$ s+ F6 e
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
- ?; B- I5 z' q+ H7 p2 ~                   Pop(optr,opr_t);% U0 f6 M  D: a+ }) A7 [
                  printf("optr出栈:[%c]\n",opr_t.ch);
+ Q. a, U, j) Y* {                   if(Pop(opnd,b)<0)  o. P' G; j% b+ T- D
                  {8 g# s6 J& }. V" Z+ H# k
                     printf("Bad Input!\n");; j; l8 n& N& p
                     fflush(stdin);# t: O- l& _* ~! H8 O. Y
                     return -1;! f6 t! q* @) B6 y
                  }6 @) r6 }  Q7 D/ C. `
                  printf("opnd出栈:[%f]\n",b.data);
& S0 ^! s' L5 D- h! n* t: y                   if(Pop(opnd,a)<0)/ A) ]. B2 ?& a8 u6 S" K
                  {: i* r+ Q2 H4 E* e' E& j; W
                     printf("Bad Input!\n");
: q' p/ P& @3 x- b. B, J                      fflush(stdin);# A! H2 `6 e! D' o; N+ X
                     return -1;
! Z8 }# T& q) _* o                   }% e, H9 x. N' ?! x( x: n+ x( n; I' g
                  printf("opnd出栈:[%f]\n",a.data);& o0 C2 \- a5 c( T$ o- R* t
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/2 \' q2 W. S7 X
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*// f% g* j5 m" C# @  `& Q
                  printf("结果入栈:[%f]\n",opn_tmp.data);
  ]0 w  o% y* r2 `                   break;, ~2 X' b  s; f
         }
! W/ p! m# t+ y* d       }
7 Q2 \" s- f6 n7 L/ j; A       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             7 B: z2 w; y( g+ i) l
}
1 a- g5 ^* {+ p. L6 }  g; m GetTop(opnd,opn_tmp);
% e0 h' y$ N& W) _6 t3 o, H! ` DestroyStack(optr);
8 e& b; z+ [! h& |- ` DestroyStack(opnd);
; |. m  s7 `* M- T- o$ g return opn_tmp.data;
' r. d1 j; U- z0 E4 a) O0 u5 V}
% C7 @. c% z8 T3 z" Q
2 ~. x( d0 @9 ?char *killzero(char *res,float result)+ h0 R9 ?; |$ b- z! o1 j
{
; f1 \3 I- c9 a& `+ c int i;- c, n3 @+ I) n4 v3 l9 u
+ W& P# X; k' a: j
sprintf(res,"%f",result);
! V" n0 ^. M" @! z# {8 L i=(int)strlen(res)-1;7 a( H2 F+ z* W& C) E
while(i&&res=='0')
7 E3 g3 J' g; ^" @ {
, X  |/ R7 r4 ?, m7 x       res='\0';
: |; D+ v' K1 |# P0 ^       i--;
( |, @3 w  f: _9 \. ? }" M  i6 n0 Z  I. b, M! U" {
if(res=='.'). v& J' ?  m, b, {* Y! @# N& @
      res='\0';- O$ O& e2 [- P! {" g# k
return res;
& `5 m' x+ _  H: T3 m}" x' B& U7 U8 R: r4 i+ d! V

$ N8 y6 a% I8 ]9 y9 Vint main()- [4 g3 W5 M0 [& }* W) D: M
{* ?5 p+ R" h' P. C0 W
char ch;* B- W# E8 n8 }
char res[64];9 q5 U% [# D9 |* u
float result;2 v7 u8 u- s/ K) u' m
while(1)
- f! }0 L" q& Y5 C6 F {: }/ W" F( N2 V4 i
      result=compute();; f7 d# i4 X- p" \4 L
      printf("\nThe result is:%s\n",killzero(res,result));
' M# l/ y3 H. ]7 _$ s  g: \       printf("Do you want to continue(y/n)?:") ;
5 N: x8 d: a: r4 E       ch=getch();
8 a5 _0 @# d' D/ g       putchar(ch);
$ _! C1 |, k+ n6 z. g/ l       if(ch=='n'||ch=='N'). ?1 l1 S4 Q1 [1 \" I7 ^) D  Y
         break;7 h3 d: n; Q$ u9 w
      else
, @+ l0 B( _) G          system("cls");
, b! h' Y* Z2 X0 Y* s }2 N/ X* z8 O$ b/ P
return 0;# V$ i: r- `2 d0 i" A" A+ y
}

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

返回列表

C语言表达式计算器

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

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