C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>$ g0 l8 }5 |) G1 m  ]( R8 p
#include <stdlib.h>
#include <string.h>
#include <conio.h>- Y, ?7 W* a1 K- A+ ^, F
#include <malloc.h>0 _/ O7 U" h4 k, h( M; V

#define STACK_SIZE 100( s6 o2 N- O9 Q. f  r- t, q
#define APPEND_SIZE 10
$ t6 `" x/ y- j$ U
struct SNode{
float data; /*存放操作数或者计算结果*/% f. m7 }( _  B4 B" E
char ch; /*存放运算符*/
};( k% o; v+ Y5 v- [

struct Stack{4 j. d6 g) w4 ]0 s
SNode *top;
SNode *base;
int size;: H/ Q- `1 A9 F8 ?) C7 R% m, `
};$ i" a. j, \2 K# [3 U5 Q

/*栈操作函数*/7 L* F9 A. F) r+ G: u9 Y
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/" C- d# k% Z* C
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/* G" z0 c7 o0 V, f1 e" @8 G

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/$ w1 T6 J0 T8 s: J7 o
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 8 d2 b! k. m1 c, T( E7 l$ m
3 g2 P% i" d0 r& o5 I0 p
int InitStack(Stack &S)2 C9 D, A4 a, H8 @6 H  }1 l
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{7 b; g% P' i4 R/ N2 o2 Q) l. ^. L
      printf("动态分配内存失败!");0 Z; z# `- v; f4 l1 u. L
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;8 X8 i& a5 }* V, l  t
}
( ~+ O' Y( P! f  w  Y1 B5 m( l5 d
int DestroyStack(Stack &S)5 X+ S' D) x% a7 {& L2 f! C
{
free(S.base);
return 0;4 u& u- X5 r) ^' T9 r
}
2 X. O0 h" x/ E/ e: v
int ClearStack(Stack &S)' c+ N1 G1 Q, q, T) C# E0 N5 z
{* a0 f! Y: ~( ?" ]' O# i
S.top=S.base;4 h' ^9 u  I3 _1 E. R1 L
return 0;- y( w" H& R/ E: Q" x3 s
}* f# r5 Y7 X0 ?! d8 E( H

int GetTop(Stack S,SNode &e); v. l: r- B! q6 y
{/ P; k; R& r* S! V! T# H
if(S.top==S.base)
{  Y) ?+ O, p( X  R
      printf("栈以为空!");
      return -1;/ f" p; B: z$ U0 x1 I% u- n
}6 q* X. w3 T( j$ N0 l
e=*(S.top-1);, Y$ U" z1 B8 ?) G5 N6 b
return 0;
}
9 l1 |3 A# @2 s( o# W. ?( T
int Push(Stack &S,SNode e); w7 @( O1 @! t8 p( u
{
if(S.top-S.base>=S.size)1 ]% L6 c; e. A; y; x  s! o
{. g: L2 ~) j  _" R
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));( U: w6 b5 {; x* O9 W6 X
      if(S.base==NULL)9 ^( K" l: A' p- B0 p
      {
         printf("动态分配内存失败!");
         return -1;
      }
      S.top=S.base+S.size;5 ]5 y# q; m. V1 y# P# i
      S.size+=APPEND_SIZE;& L( d- e' D' F9 F% {8 y4 I& P
}$ s3 n: m% D1 m7 I! `$ m0 c8 ^) r
*S.top=e;
S.top++;$ W+ n/ r) o$ N7 N0 Z
return 0;
}

int Pop(Stack &S,SNode &e)4 ~- X8 K; L: m8 n, ^9 _2 ^5 p
{
if(S.top==S.base)
{
      printf("栈为空!");) q+ @, I: n( E. r* v: ^
      return -1;
}5 t! D  l' o5 T& {; c
e=*(S.top-1);
S.top--;
return 0;
}& N5 }. |: S* w

char get_precede(char s,char c)5 R$ f2 r7 R4 p
{
switch(s)& Q# V6 b0 N+ o2 }! @: Z$ s" x
{* ~) Y' C$ I; S2 s' p" T
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')& Y% O& o7 \, S
               return '<';. R/ q# J6 w* Z6 i3 K
         else if(c=='(')
               return '<';) r0 m/ n2 s5 X2 t) {, p( n* K
         else if(c==')')# Q4 H, E( r" _  F
               return '>';* T5 M# i( Y1 d( h& E0 @
         else
               return '>';
      case '*':$ K9 @7 M# t: M! a# h6 `% J! m
      case '/':9 ]" ?' O* v# f3 D. w/ L: i
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';$ g; h4 l* L4 f. z2 T8 Q+ B, w
         else if(c=='(')6 F7 T+ o* B  ~* x
               return '<';
         else if(c==')')
               return '>';1 i$ L& W: g1 c, A6 j
         else: b9 M, n% V/ |
               return '>';
      case '(':
         if(c=='+'||c=='-'). K# z/ C4 h- i3 J8 l" S% v
               return '<';
         else if(c=='*'||c=='/')
               return '<';% F- q( R/ A0 ~% R) l9 r
         else if(c=='(')3 [( S1 [0 `, X" `9 t  b: o
               return '<';! _* F7 s7 P% a% F1 l- N
         else if(c==')')5 U- o, D0 I8 u4 x: W0 X+ F
               return '=';
         else* t% w6 @0 ~" r6 @
               return 'E';- M1 M+ U  F: I
      case ')':0 [8 f. i9 P$ h5 ]- `. H
         if(c=='+'||c=='-')( H& N9 X- a* Y
               return '>';# f! B& O* y# o& v: M' r! N
         else if(c=='*'||c=='/')
               return '>';$ r: s/ p1 p: l4 ]3 V9 X
         else if(c=='(')
               return 'E';" v5 [" s- s3 @4 k+ |
         else if(c==')'); K) B. u" o1 q* H! d2 [2 J
               return '>';
         else4 E: ^+ S9 X& |2 c1 x( K' X+ B
               return '>';$ t& P& g' {0 {3 G& e
      case '#':: W& ^- G* E# t( x
         if(c=='+'||c=='-')
               return '<';2 O8 T& A4 b- c% ]4 b$ j4 {
         else if(c=='*'||c=='/')
               return '<';4 u4 e8 h% w+ Y) G) j
         else if(c=='(')
               return '<';0 t0 O; Z) f4 B4 D2 L
         else if(c==')')
               return 'E';
         else) O, W3 W8 R5 @; i$ C9 D9 T
               return '=';  ^  N& q+ |+ U
      default:0 \3 t5 m1 U# H
         break;
}
return 0;
}
& z& d9 C2 n! E3 q( `
int isOpr(char c)* I9 m+ ]( ]. d3 q! Z
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')7 e  m5 ~" V. _9 o' m
      return 0;! i, j. x. I1 v7 X
else
      return 1;1 n. m4 N6 d. y8 Y7 j* s  s* u
}0 A: g* s% w& _- K# @$ j

float operate(float x, char opr, float y)+ k* @$ k: M! \1 B! z
{/ @5 b* T# c2 _- l9 d
float result;
switch (opr)3 n. f: b/ o6 R; K
{5 U, ?1 {0 A9 ~( X( W
      case '+': 5 G" }$ g8 K; c/ C' w9 p
         result = x + y;
         break;
      case '-': $ C. u  E" n2 E9 T- z
         result = x - y;
         break;  Q3 w2 L! ~% F: T
      case '*': 2 ]$ ]; }* @) K- g; V: I  N9 \- @
         result = x * y;; B) F! s$ t7 P* W- e: {1 i2 ~
         break;
      case '/': # a4 R( ], @* J7 k4 j2 u9 a
         if (y == 0)( Z7 }% B0 e4 _/ ?6 l- K9 ?5 e
         {
            printf("Divided by zero!\n");
            return 0;5 N4 p( k, ~  u* G' n' M5 o4 u
         }3 x) X; h1 T+ ^$ R! z5 Y  X
         else
         {
               result = x / y;
               break;/ W5 x" t# L2 G
         }7 ~8 l: Z6 x$ l, V
   default: ) ~" I* S8 e( m0 b" @; W# x
         printf("Bad Input.\n");
         return 0;% x7 G* _" Q. p6 K$ v/ y
}6 x" M1 c* Y: u+ $ ^
return result;
} & l4 V" S5 J! ^' c; a
' N- f: g: g1 C! e" [. L  S# m: {0 [
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{# N& U( $ r. |: u
Stack optr,opnd;: q" H4 C2 N4 U
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;& \. b$ V1 W' u/ c0 J# N3 ~
char c;8 U- u3 w8 h+ }9 l" F
char buf[16];; n1 M( i" r% q8 @; I; C0 I. R9 h3 ^
int i=0;0 L& Y+ O2 N$ b6 u: h# P
2 N2 G) k  K# n( g
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");
      - B# }; f8 ^: ~  t) [  g) z- K
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')1 ]+ u! P+ o5 z
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {+ ]3 b& J( D  i7 o
         buf=c;1 U( Z# z- U" S3 T9 i
         i++;9 c, s# b& |8 \7 q
         c=getchar();; i0 B9 X1 X+ B5 M' l
      }
! V: Y" c$ e  V% O       else /*是运算符*/0 V6 R! @/ M: i
      {. Q  k. F& f, `7 s
         buf='\0';+ e# M7 m& t8 @% N1 N+ @
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/5 l* s: A6 S6 |/ Y3 i
         {3 J. ]) ]8 T9 ]* O
               opn_in.data=(float)atof(buf);
$ ^5 L2 ?; W/ n                Push(opnd,opn_in);) u! @1 f9 ?  D9 d) V
               printf("opnd入栈:[%f]\n",opn_in.data);/ a3 w4 S/ [" X" }+ w% R
               i=0;, Y/ P; M* x/ z; |& Q6 B$ `
               memset(buf,0,sizeof(buf));
3 K) c/ s* ^8 f. l' ]          }
. w& H% p3 o$ d          opr_in.ch=c;, g! {) E# Z8 Q; ?" N( m' V7 s
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
2 h- \  N9 \3 S2 E! z2 A          {! I- x4 O' j' Y6 C2 i5 a! X: u
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
# }+ u( Q/ |% x4 f4 O                   Push(optr,opr_in);* ?1 ?8 s5 l: I; O# y: u
                  printf("optr入栈:[%c]\n",opr_in.ch);
- o. E6 f% i7 ?9 q) X                   c=getchar();
% u" H8 k, q& Q  h2 Y                   break;; Z* Y; r. E4 p7 ?4 }) H9 m5 U
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/: `$ i6 u. \: Y: G1 }/ H
                  Pop(optr,e);# Z) p5 v4 W4 x3 z+ h/ b" G
                  printf("optr出栈:去掉括号\n");# a+ Z- H$ v1 c7 d) Q9 B8 g9 x
                  c=getchar();
/ i* |% }- q1 p* {6 i3 ?                   break;) o  v/ \4 k+ l" j4 ]; Z
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
+ l% r: k$ H9 T% U9 _                   Pop(optr,opr_t);4 S  W( I2 e1 p
                  printf("optr出栈:[%c]\n",opr_t.ch);# S% K! V; s5 a: l/ A
                  if(Pop(opnd,b)<0)
: Y) X5 H3 H3 W; V0 q  M! O: j                   {
2 h, M& b) n( f# j8 Z2 j& Y                      printf("Bad Input!\n");
! h6 N) r, J, Y# K3 j8 G3 `! C+ u6 k                      fflush(stdin);
9 p$ D3 ^* E* ]# B. q1 L                      return -1;
, o7 M/ j& Q! P& v$ m- W                   }
8 u- E& X4 q2 W# R* x                   printf("opnd出栈:[%f]\n",b.data);
6 b) C! P2 n5 _0 X7 Y1 N  }; V                   if(Pop(opnd,a)<0)' I# G$ B9 b$ f! h' M: i6 D8 ?! }1 p2 H
                  {
" e7 Y* }( h* e1 f                      printf("Bad Input!\n");
' u1 V/ I1 K- g  ?$ V# Z1 \% W                      fflush(stdin);+ a2 o  e6 q) O: j4 T% @, g9 v
                     return -1;
- L" q( g. u& a8 T, ^4 N                   }
6 Q4 F- _( l. z! E) ~+ f3 k" x- y3 e                   printf("opnd出栈:[%f]\n",a.data);" E* ]! [1 T* {7 q) {7 U
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*// b) u9 ?( G" N2 K7 x! t0 M5 p8 Y
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/% L6 y2 u7 U" Y7 ~. D. C
                  printf("结果入栈:[%f]\n",opn_tmp.data);* g! Y1 k$ {4 F& U( w/ _; e
                  break;
" o$ y6 c  E: ]3 s3 Z" F6 k4 ?          }
1 ~5 c3 d- ~! C' Z: @       }
; Q" t6 g2 M" X- `) n       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ' U9 Q1 f% t5 C
}. m  m4 b3 i+ \* F" g' a. I
GetTop(opnd,opn_tmp);
& `+ x4 O3 M8 d5 s: q: I DestroyStack(optr);6 J9 ^% C# @0 ^( J+ r) }
DestroyStack(opnd);2 F2 q3 v3 P# X" N) f
return opn_tmp.data;
$ d6 W! x" n2 ]& Z9 a3 \}
% ]6 O# [9 Y( h' m; {, q  H% h( H! s
char *killzero(char *res,float result)8 |8 U5 {* S. W) j9 u% _, h' s& t
{  O4 i. J5 ^5 W; A
int i;
3 r0 q, r0 I7 M  D8 O) o; u5 y& o* x+ i* Y0 s, E* k6 B
sprintf(res,"%f",result);  m3 u! s3 [. A3 f( U7 y8 u) u9 w
i=(int)strlen(res)-1;$ L. ?( q, F& j. O( @8 B$ k
while(i&&res=='0')0 ~+ @7 e6 K! ]- k- V
{
5 j% F) T4 c0 p( {! Q       res='\0';
) m! o/ {3 p  Y( Q& Y       i--;6 i3 S! s5 z% s9 K* x
}
/ ?5 O$ S; m- F  U if(res=='.')
. b) W# ?# D  \9 j- P* O- {       res='\0';
1 y! L8 i+ q) O, }; C! o% j( `5 s return res;
4 A* q9 i: b& }) r}
& \9 q0 c' X8 P7 H  Y" ^4 Z* ~0 w: g4 w% c4 g. f7 D; n
int main()
/ S) n. y/ R0 x+ E{
! e/ m, S/ R' v3 {2 n  U char ch;4 k) Y/ K' V$ D3 u9 {0 g
char res[64];, l& w6 ^* e0 I# S) o
float result;% o3 r6 ^( y4 P
while(1)' J  ?: w) x( S8 U& m, I
{
4 u) Y) T* @$ W! j3 J" ^       result=compute();
) Y. O6 U* s9 J8 L' _; J! M       printf("\nThe result is:%s\n",killzero(res,result));
. X& S4 b, @* L: _* N' \1 @       printf("Do you want to continue(y/n)?:") ;
" m5 }  M; F% h, b: G% c5 U+ j" G       ch=getch();+ ^, j* e- N0 T8 ~: x( f) S' i+ c6 h6 \
      putchar(ch);
' r: F6 @+ [* s( b/ c       if(ch=='n'||ch=='N')
' u" D  c: k  E$ i# Y          break;
: \) x' n) C4 K: U       else
4 g6 `5 ]) M; H% _% Y; Y8 @! @5 A          system("cls");6 W" S" e9 E6 l( a2 ?! }7 Y
}
return 0;% t+ J* i: Y* Y. S( _# W$ F
}- \8 g" J6 x- }. g+ I+ k# O

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

返回列表

C语言表达式计算器

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

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