捌玖网络工作室 - Powered by Discuz! Board

标题: C语言表达式计算器 [打印本页]

作者: zw2004 时间: 2008-1-21 17:17 标题: C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 1007 Q+ q4 l# q2 M- L6 g
#define APPEND_SIZE 10  d. d( |5 d. t% m9 ]! L( v3 {
+ o6 a! A3 `0 b8 ?" V2 e0 M
struct SNode{1 A% @+ n: y+ J# V
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/" I6 e) n1 C0 v! X0 j# t$ [- A1 C7 a, c
};

struct Stack{- r' ^' {# S3 B# g: s& U+ W
SNode *top;
SNode *base;$ O% i9 j& a+ V% t* A
int size;
};( p( s8 a1 v) l. T. ^- h$ l  J

/*栈操作函数*/' L. n4 E8 R6 k) `% e- l
int InitStack(Stack &S); /*创建栈*/* x+ w8 }2 L+ {3 @! Q9 r& X5 J; ~
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/" c# {8 A# r/ y  a) R
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/! T( ], Q, P4 G; q9 Q! W

/*表达式计算器相关函数*/& `  e" M6 ^) q0 l9 c) t
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/  P( ^1 z, P& U3 G4 g% ~+ t
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/# h* X; D1 C: _; Y, v
float compute(); /*表达式结算器主函数*/1 N1 n7 d  C' v" n: |5 B9 n( {
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)" m3 c& L; N& w) b+ F( v
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)  k' n; O# Z' F: P9 A* l0 o
{5 |9 m# e: P" c& h% v
      printf("动态分配内存失败!");" l6 B. X& Q/ }( o
      return -1;
}$ Z1 D6 ]: j8 J! ^3 `
S.top=S.base;* O/ I* `9 K, U6 K* y
S.size=STACK_SIZE;% `. f" e6 z5 n7 V: A! W7 X6 q
return 0;
}* L) M( `( d8 r3 ~( S
$ G3 P# m' t; ~
int DestroyStack(Stack &S)7 }4 n) R6 _. S1 r$ g! M
{
free(S.base);8 ^6 L0 R6 j) S- \4 D2 f
return 0;% D3 Y- j4 I! k4 D
}

int ClearStack(Stack &S)/ [6 o% _4 f, s( e4 q
{2 V# X9 h7 O* f
S.top=S.base;: v& o2 G: k( C8 @# `
return 0;
}
0 m/ w+ V: L' k- a6 E& W: R
int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)
{
      printf("栈以为空!");
      return -1;9 w9 I  E$ j4 v' u" L' b' ]# }
}7 P+ J& `8 w, s' d+ o4 f1 M- u
e=*(S.top-1);
return 0;
}' F3 h, m" S# X( B% P$ h: {

int Push(Stack &S,SNode e)
{) I3 e) ]) _7 T5 h* ]
if(S.top-S.base>=S.size): Y0 {( D+ [5 J+ Q3 A
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));7 M* T- L/ k* u; Q/ U2 V, P
      if(S.base==NULL)5 T  k, o2 ~$ [% C* X
      {, L2 T; H/ v' Y" a* e% c
         printf("动态分配内存失败!");8 n+ G- G! b% N# q! c! n* F
         return -1;  i; G9 v! N& V
      }/ ^3 [! d) c8 j, p/ N# p# U: C7 s3 m
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}
*S.top=e;
S.top++;) E  ^' S, N0 X- a( q, u4 @
return 0;
}

int Pop(Stack &S,SNode &e)
{/ q! F6 k: p' Y2 Z9 v: i( ?! ^
if(S.top==S.base)$ V5 Z9 U% h& @- r' b4 V$ f, x$ v: q
{
      printf("栈为空!");) L$ q1 M1 j( D+ x$ y/ B  e$ r! m
      return -1;/ y+ p  t" g' |* y7 |5 a4 R
}7 W: @# s9 b" |# }" y
e=*(S.top-1);
S.top--;7 K, ^8 P7 H& g9 }; k4 D& A
return 0;
}

char get_precede(char s,char c). B1 y9 o7 b6 B- J' o  T, _
{( F) A$ g9 V" W( J5 }, r( W+ u& q
switch(s)
{
      case '+':                . y% Z) w1 W9 J) R2 o) @. B
      case '-':" m/ }; d" T6 s' [& z
         if(c=='+'||c=='-')6 f' B5 O  P; s: V0 v: Q
               return '>';
         else if(c=='*'||c=='/')4 `/ _0 B, S1 a: N
               return '<';
         else if(c=='(')
               return '<';' c5 J) w" r) i: a! n4 X
         else if(c==')')
               return '>';
         else ) n0 g4 g6 e  X2 J" w, o9 j
               return '>';5 q- I2 Q5 @5 h) K/ r2 o7 u
      case '*':
      case '/':. {# C* p& e: u0 y1 Q6 ]3 }$ O5 R1 r
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/'), m+ v* l  W; B2 W8 ]" G  g$ i
               return '>';8 R& w. k+ F% I8 j
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';) c0 b) f' _! e8 C" v. a& r
         else
               return '>';$ `+ b7 o" h  h- ?. G
      case '(':
         if(c=='+'||c=='-')
               return '<';, g, {& E% x8 j3 L4 O
         else if(c=='*'||c=='/')% S6 t  ?1 r* z
               return '<';
         else if(c=='(')! }, l5 W' `& W4 \& F* y
               return '<';
         else if(c==')')+ u& x, Z. y+ v! m6 T) Y. A
               return '=';
         else
               return 'E';$ I& V$ n7 Q$ [2 `: |' F
      case ')':# O2 N8 B  b- H8 @- l
         if(c=='+'||c=='-')6 q+ h. {8 J% k( t) \+ P% |
               return '>';
         else if(c=='*'||c=='/')' ]6 U: }0 o8 e  G! V8 w  M$ L6 i- X
               return '>';
         else if(c=='(')
               return 'E';  L' l. }% L# |
         else if(c==')')# n' j( z8 S; `0 R$ `7 t
               return '>';
         else) @# V  k* ?0 {# T2 q% M
               return '>';  S( C4 J' x5 J7 q0 H
      case '#':3 z" h* y0 p, {; ~% O4 T
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/'), x2 P! R1 {" g2 [5 k4 D; \
               return '<';4 E) A) E8 W, {- A3 g' F* K; _
         else if(c=='('), w" L" f2 F8 S" u4 N- K1 ~
               return '<';
         else if(c==')')' Z9 a# ^4 r2 q& @' f
               return 'E';( c. ?' U, o5 h+ c3 w; S, T
         else
               return '=';
      default:" P  q6 a; ?( d8 T
         break;
}# m6 v+ c: [$ H: i
return 0; ; z$ ^* M3 f# t
}: V! b; k' H, i- x5 H

int isOpr(char c)
{* S" e# e" T* `. [7 y
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;
}

float operate(float x, char opr, float y)
{
float result;
switch (opr)
{
      case '+': $ e6 e8 V& B! R5 h
         result = x + y;1 i0 r5 @: S; p8 o7 @% f3 F% B
         break;! n8 X5 c1 q. w- M! W/ `
      case '-': 4 w& ]0 B$ \5 j* L
         result = x - y;7 D0 \" C" {2 l6 |
         break;
      case '*':
         result = x * y;
         break;
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;0 l; O+ s$ b& c; {4 _" [
         }( N$ |: U) o! {0 b
         else% u" q; q/ P# B
         {% m; j, ?: H. U
               result = x / y;
               break;
         }: l; [5 F* Q+ I% e
   default:
         printf("Bad Input.\n");
         return 0;
}
return result;
}
. d1 W7 E7 d& o0 i8 T
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;# y9 ^: j" C. r! j: o% t9 T8 p
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;/ A  {2 ^) D, ]' p' S! p
char c;
char buf[16];
int i=0;8 I; b0 g, z6 C0 ^7 |  K2 D6 W
+ B1 h$ Y8 e& p5 |
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
- N& g7 o, N, k
printf("Enter your expression:");
      ) U! q# S8 @/ f
opr_in.ch='#';  O0 @6 ?4 h% j7 U! v
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);: x$ ~7 ?( t* y
c=getchar();: f9 ^% u) a2 C" g- k
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/1 R' `9 _& h% w) I) V& ?) B
      {
         buf=c;" i* m( V, q4 I9 O9 Z
         i++;
* ~0 X/ {& K9 `          c=getchar();) z) [0 R& E/ C
      }' r: D7 \4 |& x; U5 G0 ?% I) i
      else /*是运算符*/) h- s9 }& N8 \8 Y7 Z
      {
+ n& r+ k# p" p: q% ?          buf='\0';% ?  p! E, \! \/ J2 i
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/" _/ L' }% \/ t8 h6 U
         {  n! c; ~6 u  q& w
               opn_in.data=(float)atof(buf);
! H$ t- w' A4 c% J/ T% Q; I4 g) I3 e                Push(opnd,opn_in);) o. _* B- Q$ s
               printf("opnd入栈:[%f]\n",opn_in.data);: u2 [/ F0 ]2 t2 T% |8 f! U
               i=0;% m  I" T0 ^5 r& \" L; m
               memset(buf,0,sizeof(buf));  n: A3 `0 h! x* r! z
         }, X$ M; V0 K0 f5 I' ^! s) G
         opr_in.ch=c;' J2 \* l9 l9 l( D7 }4 G$ _; u
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/, L$ \: t  D0 P9 A. P8 s: l
         {, T# e% @( l: p3 d: M
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
9 m" i0 w+ R! W% b1 H                   Push(optr,opr_in);* j  Z* f8 r/ i0 y3 m% M+ f  v
                  printf("optr入栈:[%c]\n",opr_in.ch);! l& f8 J5 \1 Y' D2 B% l" i( W
                  c=getchar();0 R/ K  E2 v0 f  D! [6 v9 T
                  break;; w6 e7 K/ p* P. a; X' m) F, {
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/' \. l" N& F/ i2 h: _
                  Pop(optr,e);3 D" E: |% [$ N1 f2 k
                  printf("optr出栈:去掉括号\n");
9 V: A# `' C  f: z                   c=getchar();
; \9 ~& X$ j+ z3 t  g                   break;4 [9 b8 X. m  U- Q
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
1 D0 H- y4 J9 s; q5 O( @7 ]                   Pop(optr,opr_t);
8 V! [9 V- q, s& D% [/ _                   printf("optr出栈:[%c]\n",opr_t.ch);" |" H- W$ k3 E! x- ~5 a
                  if(Pop(opnd,b)<0)
7 M& s: P6 F! T; o. r( `                   {
' }; D2 a4 v$ j# Q5 l. F                      printf("Bad Input!\n");' U: M* ]/ K3 _# ]7 }% g
                     fflush(stdin);
0 n/ E0 G2 Z5 r+ ]6 B- U                      return -1;$ L4 j  g/ s% X3 Q' T$ M& b0 k
                  }, \5 P& t- m( i6 n2 _- D
                  printf("opnd出栈:[%f]\n",b.data);
, k: q) F; d% G9 J& A                   if(Pop(opnd,a)<0)0 F. {7 B% Z8 p3 q
                  {& y& f) y# |4 R; c: A4 s; y4 A
                     printf("Bad Input!\n");' Y' q5 d8 K* ]& r6 h. N
                     fflush(stdin);
# O- a4 u& K2 ^6 K                      return -1;6 z8 k4 u* T; d( L
                  }
1 k- M' M. s. u8 M                   printf("opnd出栈:[%f]\n",a.data);
  R1 u; Q# G) r# b                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/; b0 F1 B5 S2 I" K) A
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/7 l7 {+ ^; L7 n3 o
                  printf("结果入栈:[%f]\n",opn_tmp.data);% z" @6 I: P5 j$ z+ g9 e0 q
                  break;# `# E4 E( T% V( G+ G% s0 U
         }
, h1 W; i( K: G5 Y; C( C$ Z1 z       }
- ?& j; c! R3 P+ P" n       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
; ]5 u# z. E; w6 ~" w) B }% }) M) `- ^: I  U1 y, `
GetTop(opnd,opn_tmp);
5 k" K' m. i5 \" G; p; q0 m DestroyStack(optr);
1 _! h5 a; D1 X/ v% g DestroyStack(opnd);
. t% X5 ~* g; C* J  k: |# R return opn_tmp.data;8 N& U4 A) g0 G9 o$ e. ]. U
}
/ T% \3 V/ A+ s4 `1 _5 B$ N  o. E
char *killzero(char *res,float result)3 }, G* D0 m9 w- F; a& {
{
8 b" G" m( m$ | int i;
9 {4 Q4 G6 r# C3 R. C+ R2 v# n
8 a0 T( Z; C' K# O9 c1 ` sprintf(res,"%f",result);. y! h/ j; T" ^$ o# j+ n
i=(int)strlen(res)-1;
8 X0 R, v0 N8 O$ N* u' D3 g while(i&&res=='0')
: X9 G: N' p9 Y; S$ z" ?# L {' E" r" M7 F/ Q- S
      res='\0';3 \4 U! A3 g2 e& ]7 G1 p
      i--;8 I' P% N2 J: Z
}) n6 P, {* V8 y6 t( L8 h
if(res=='.')/ z2 p8 F4 f# S3 r
      res='\0';: d1 D) B* I, @# R' d$ }
return res;
4 ^% I1 b1 v+ V# Q2 w% ?}0 M1 q; f# w6 n
% M$ A$ l* h$ T( M8 c
int main()% L% `5 g0 [. D( d
{
+ E; [6 f0 |# D8 u- H char ch;9 m. I) L7 p% x5 F! ?
char res[64];
9 O0 o* r+ |/ a; i5 X5 e float result;
9 X7 Q& }6 \9 u  Z2 d0 P+ | while(1)3 N0 Q' V( t& D
{
4 t6 S6 o+ \' ^% H! S       result=compute();
) \3 U, A4 s# c& N       printf("\nThe result is:%s\n",killzero(res,result));. I3 c5 {; V8 N! S* t4 @
      printf("Do you want to continue(y/n)?:") ;$ X& Q6 u( g* l* e. S) r; l7 s) `
      ch=getch();3 C, _* z0 L- S/ R8 X) _7 E+ t  B
      putchar(ch);
- D* n' v4 ^; [# N3 B       if(ch=='n'||ch=='N')
( A& k" y$ F7 D: \. S          break;
. K8 s# [5 J( g4 h3 J       else" J, v5 t6 I+ Q$ p. X3 ?
         system("cls");
+ E, C% k* q) k7 F, v7 D }
% i, _+ I- @" `* @# @  C7 e return 0;
$ l, E  _! Z0 j  H}/ j' \$ |- x; _
* R* z- S( A# ~  u
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

欢迎光临捌玖网络工作室 (http://www.89w.org/)