C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.! y' V  h4 c1 N! z5 a
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=! {# [: p0 H+ K# L9 O: ]" }9 i* o
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>  ~  R& I$ h7 U* W; z
#include <string.h>+ I3 b: p2 Z# }/ t8 C- t$ W, Y) H
#include <conio.h>
#include <malloc.h>( F9 \, y# y1 U

#define STACK_SIZE 100
#define APPEND_SIZE 10' O- S9 T( T( d/ L  {' I

struct SNode{
float data; /*存放操作数或者计算结果*// ]# t, B  L$ M6 W, M+ P" I
char ch; /*存放运算符*/; i6 Y0 R8 @+ p
};

struct Stack{
SNode *top;
SNode *base;
int size;
};/ A4 S" N, w# u% D4 N/ S# D
/ o5 [( U, K/ @) S$ e5 A; k
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/$ S- q2 L2 ~$ j3 P% T" o
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/% A1 O4 p' \' ?  V( S& h

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/$ B# y0 |  @' W6 ~
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/) U, w' o! d2 E, N2 P
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/& }; \& V; z7 `/ h3 s0 l
float compute(); /*表达式结算器主函数*/7 k' P2 v8 i  P. y# g- ]% u! e
char *killzero(float result); /*去掉结果后面的0*/ ; y, v2 }1 e- q& Q' J3 f* T, O; c
1 q9 T+ h; K8 G! @( a) B
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));! l& s1 R4 g" [# k7 Y. I
if(S.base==NULL)
{( B8 R& d3 A3 Z" w2 _/ e
      printf("动态分配内存失败!");
      return -1;5 V6 U! v# q: Q$ b) P: ~% o( A$ R
}
S.top=S.base;+ a) D& _& v) Q" R8 }6 n
S.size=STACK_SIZE;
return 0;
}4 @9 ~, O: X  N* W# }1 m& j  R6 p
: q. R0 n: ^" u' n# c4 u/ H2 O, c
int DestroyStack(Stack &S)
{9 S7 c/ o0 V  \% q' |; }1 `
free(S.base);
return 0;
}$ |3 d! ^9 u  D; J

int ClearStack(Stack &S)! @- h* `4 _1 Z0 j9 S- r
{
S.top=S.base;4 k' N& F: }9 u& G* G0 s3 V
return 0;$ [1 `* C: T8 A2 D  F! U5 m' C
}
0 S8 y& g8 [* R$ D- q2 A! s: Z
int GetTop(Stack S,SNode &e)
{7 ^/ x  i1 d" y% B$ $ {
if(S.top==S.base)
{5 l! M' D- ^2 ^+ g* b/ o0 z' @" b' t
      printf("栈以为空!");) q1 v7 f! e" S7 _+ k! Z" [- a- |
      return -1;
}6 o+ o* y3 g8 P: s- w
e=*(S.top-1);" g: \% [, }8 ]
return 0;3 u; m: I* _; L
}

int Push(Stack &S,SNode e)5 ]2 K6 n1 x! ?3 l# d# I8 D
{
if(S.top-S.base>=S.size)2 a7 ?+ R# O2 d. ~* t
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));. h  A' z0 o1 P
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");9 Q8 v/ x( _$ i6 Q' B. _
         return -1;4 K/ j: Z0 h6 d0 Z) u
      }5 ]9 c2 k6 Y7 i0 r( ]) ]8 k
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}+ Y7 N$ {0 h6 i) `- g& d6 G
*S.top=e;
S.top++;
return 0;
}; [& l( m% X) X+ Z; g0 `' {, \
: m" |) V! v# @
int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)# ?. [  a' ~: V: M" l9 d7 p% Q7 @
{3 ~. x# e: A! n7 w* k
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);
S.top--;# f1 o5 H  b, i: l: w  {& G
return 0;5 B9 N4 K, $ M) m7 P
}0 u! F7 I: I" e3 s4 k* j
) d$ Y, M* H& y$ `
char get_precede(char s,char c)
{
switch(s)# y1 L4 h; k, c) l8 `8 a3 W: S5 m
{
      case '+':                # g) Z5 ]) t1 F) U) c
      case '-':
         if(c=='+'||c=='-')
               return '>';  e+ }3 t# i1 `. H
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')4 u% _8 g! u8 H/ c9 z5 O6 `! ^6 t
               return '<';' i( A4 t" k7 v0 e1 T
         else if(c==')')3 \/ a+ F) E5 E" N; t
               return '>';9 a5 y" \4 y+ R( I
         else / Y" e4 d. W' D
               return '>';
      case '*':: f) f( p( t: ^0 W
      case '/':+ t% y  y, _; H- i
         if(c=='+'||c=='-')2 }9 N$ n6 }. w
               return '>';, s; W  m: r! \9 K/ h7 _; ?
         else if(c=='*'||c=='/')
               return '>';0 [, m0 U) p$ `9 x
         else if(c=='(')$ C" x9 |$ ?  l& |# g
               return '<';
         else if(c==')')
               return '>';4 F8 g7 O7 M# b  s' L( O4 B% g
         else  R0 ]$ n+ p: E
               return '>';# [; a6 D2 }. w. @4 w; J
      case '(':+ D% H9 ?8 |+ a
         if(c=='+'||c=='-')
               return '<';) n% O$ V* h& [% |
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')( ^; R) f8 r! L4 z! y7 s
               return '=';6 e% [1 _, L9 i( K( K. L  ?
         else( {2 t7 C$ x9 V' y/ c, a
               return 'E';
      case ')':% {8 z  Q8 P  l( c" q2 ]
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')" a' H- v6 \' _( b
               return '>';, J! Q' b$ |: U/ ~' {, c
         else if(c=='(')
               return 'E';; x: A% z8 K' ?' x) T
         else if(c==')')% E1 r6 ]) f; s3 U  P# {
               return '>';
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')$ x8 P2 |2 U5 n6 s" r+ N
               return '<';3 V9 W1 s% A) t1 W! o( y. e) T* b
         else if(c=='*'||c=='/')4 v# y; j; M4 _/ E# ^1 W
               return '<';& A* B) X5 t* u- c# N3 B* p
         else if(c=='(')
               return '<';0 ^- [# I( r# j# E% Q" X9 c7 [
         else if(c==')')$ m! \3 o: d; C5 q5 @" _  ~
               return 'E';+ r( C1 Z. z. H3 T* J! S
         else- i- H+ I; O. S& \% m5 i6 ~) J& P
               return '=';
      default:
         break;
}; Z# ~4 C. n# _( r+ J2 E, D
return 0; 7 M- {9 n& l9 h  c) g
}
* I* T. b  m& \) h* n
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;. W4 N5 n' y/ V" e" H. K
else   Q# k( d# W6 Y$ |
      return 1;
}. v* o9 w4 F* b% s8 o
+ @7 r4 {& \5 h" g
float operate(float x, char opr, float y)
{" H2 G, z- t0 q# g( H
float result;
switch (opr)# x* T0 d* B  h- c' `2 m+ g- m1 y' V
{
      case '+': 7 G" [& z) f% m2 `! `5 w
         result = x + y;
         break;
      case '-':
         result = x - y;  ~& D$ e# }# t% D
         break;
      case '*':
         result = x * y;
         break;: U2 r% E: H, o+ m! k: Q- r2 o
      case '/': & v- ?! w- h! R5 N) k
         if (y == 0)5 f6 V0 ?4 o% d9 ^3 a: x
         {# Q( `5 X; U% x
            printf("Divided by zero!\n");
            return 0;8 R# t$ k$ m' X8 U& O* O' i
         }: i9 I  l: z8 N+ ~5 V4 p! r
         else
         {
               result = x / y;
               break;
         }
   default:
         printf("Bad Input.\n");
         return 0;" b1 I5 W! U- ]6 S  B% h; @
}# H3 C& c# s8 Z6 [! F  u* z+ N" X
return result;
} ' s+ n; p" E. Z

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/2 W" _4 @3 I1 c
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;& w6 o0 o9 _5 ]
char c;- k! u" R$ V4 ?- C) }' T3 w1 ^
char buf[16];
int i=0;7 H/ H# q2 p5 c/ C' H
1 {8 \2 O9 }' a% ?) G
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/( ]; ~" b- _: r) m
memset(buf,0,sizeof(buf));
4 ]5 z& I0 Q. @: J/ O
printf("Enter your expression:");4 K. n; W& E$ ]" o8 {/ F  ]

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/3 ~! F  o$ S7 t8 t0 Z- J  ]( Z
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/7 R, @# S7 x4 K+ {9 D$ X% P, C9 {
      {
         buf=c;
& C% B- o, i# T5 w          i++;
8 \1 O2 A# a  @& e" |" x7 \          c=getchar();
- @$ O* i" U8 o6 P( o       }. u/ P  C5 S) C% I
      else /*是运算符*/5 V% }' F2 _5 ?! b0 H' U- _
      {
' K. u# n$ R8 h; g6 t' i          buf='\0';
  q/ n! t' y$ d  @: U! E          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/5 E9 I) t% b2 r1 R- O
         {
. K( N1 ]' f- E" N  I                opn_in.data=(float)atof(buf);
4 {' w1 T7 d3 k0 A8 v  e                Push(opnd,opn_in);  n& A5 u! g$ j; _# g) H/ J2 L
               printf("opnd入栈:[%f]\n",opn_in.data);
& U- l# \) I2 n4 f) W9 M7 K  X                i=0;! s# w# K: ^! e! G$ j9 X- R
               memset(buf,0,sizeof(buf));' F$ a4 g' {) E- |  H" \5 W$ b
         }
5 n$ X$ Y5 Z8 f5 _1 q3 v          opr_in.ch=c;
4 s2 K# Q8 m7 F          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
5 U( |0 ~" @: R' ]1 b          {# V$ t# H3 O9 }
            case '<': /*优先级小于栈顶结点,则运算符入栈*/# M* O; |; w/ T. W3 s1 [6 K1 z
                  Push(optr,opr_in);
! s; ]$ i% \8 q4 E                   printf("optr入栈:[%c]\n",opr_in.ch);
. w4 Q* F; R- c+ g5 D$ u4 m                   c=getchar();  M3 M* X& R5 [; u* |( C6 |
                  break;
# f. h0 M2 G1 Y( d             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/% f4 b6 |' t6 w/ ]" }( k
                  Pop(optr,e);" \9 V$ }3 F$ G8 y2 \
                  printf("optr出栈:去掉括号\n");0 P. M" K. e3 O4 r& t7 k- v. i: }
                  c=getchar();
  c' U0 D5 {8 Q) Y. L                   break;" E7 n5 R3 R% |% z: B6 R
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
% E! I4 t( A; {, ?6 f& J* Z6 ^                   Pop(optr,opr_t);  |9 A6 ~/ t3 y: p* f9 i0 j; r
                  printf("optr出栈:[%c]\n",opr_t.ch);, F6 i0 L- d4 z7 S' ^
                  if(Pop(opnd,b)<0)
% x; o. Y" A) R( h* |( g                   {9 z9 Z$ J9 W& Z& T4 R$ u* {
                     printf("Bad Input!\n");
' s: b2 y. o9 v, U# ?                      fflush(stdin);
: M; F, |' b3 T                      return -1;/ E7 L, m! n4 i0 M% U  E
                  }
: C, D% V9 R  p8 t7 g                   printf("opnd出栈:[%f]\n",b.data);1 G, p# N' `8 G6 U6 Q8 m" }# i( d% v
                  if(Pop(opnd,a)<0)& ~0 P* W' F. U5 W/ A! w% `
                  {* |& S; l7 U* t, [( Q
                     printf("Bad Input!\n");
, h" z# u; v7 H$ Y8 l1 T                      fflush(stdin);4 o: o: @3 d7 l6 [. H
                     return -1;
" I8 k# `$ X* O! k. |2 p                   }
: a5 p" O5 B8 W1 g                   printf("opnd出栈:[%f]\n",a.data);
! ~- C1 F  K% X                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
% c! C, i% ]0 U                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
/ }$ t) j& _, R) y/ H                   printf("结果入栈:[%f]\n",opn_tmp.data);
                  break;
" C- M8 V0 I0 L7 q4 Y2 I2 s  i: ?          }
$ U8 B! p0 z: `8 `: L# a. \       }
# D( B5 y  x( X* `; ]0 B" X5 p       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
6 b" Q$ E* M. N1 w" F6 q. X }8 ^5 ?. r4 {9 p2 Q! Y/ `
GetTop(opnd,opn_tmp);+ i0 P6 a1 i0 l0 Q
DestroyStack(optr);
# |! |/ Y: ?: e1 q6 d4 c; N6 H DestroyStack(opnd);2 |. r. L$ J5 j2 f( c
return opn_tmp.data;
% d$ ]! _, R8 M" a& h}
& {: ]0 T8 a7 F- ^0 g9 @  \
, B* `- J7 N% N& e4 p6 J& mchar *killzero(char *res,float result)7 |, k- W9 `; e" I( d0 F# h
{
* i# p7 X: z% S: v, n int i;: p; I6 {" h) W/ T" ]" [

7 h- R$ A( n+ \$ l/ J: b- K4 z sprintf(res,"%f",result);
0 ]: k6 j: G3 I+ X* v' c2 ] i=(int)strlen(res)-1;( u; ~& J2 K. J2 P7 b  w7 i
while(i&&res=='0')* v' B- Q& Q# n# l9 w2 r- ^; N
{
* t6 c+ `% g6 a; \5 t5 t! I/ a4 r       res='\0';3 n4 N  h& V: f2 k& s/ Z& Q
      i--;) z, M) n3 x/ b) b: j7 e* S2 Q
}
( W) h& b) u. c9 X% [8 T0 k if(res=='.')
6 g3 y& u# H* a       res='\0';
. p" l0 l1 @: s4 e7 t return res;
. Y, D2 v, O, M2 [6 E: A% o# K}: D/ E, @$ M( {1 X4 z
* U8 M) p, c+ B) \0 o; [4 B, ~
int main(): J) W* N+ J* s1 `5 P
{9 x; _! _# _" n( R
char ch;" m# ]% f5 R3 [7 z: }( j
char res[64];0 |  z1 S! ]8 [7 H% [
float result;
# k+ g4 C6 Q% p* G  w while(1)
) r1 k0 g; y9 r1 C4 | {9 l* n& x* _* Y+ d8 `" x; S4 q
      result=compute();  V" ^) G; Q+ o( o; z* z
      printf("\nThe result is:%s\n",killzero(res,result));* U! ]2 E, k' m7 r* y, I
      printf("Do you want to continue(y/n)?:") ;5 Z1 N0 U/ B: m4 z1 Y
      ch=getch();
1 V7 s% Q8 t, q$ s% i       putchar(ch);; d+ q: R$ j' u( I# i/ H0 {, {: o
      if(ch=='n'||ch=='N')
4 Y9 L0 E% D, d          break;
2 U; W' V$ T, ^+ \( G* m' N       else
+ }9 M; v8 |* L  U          system("cls");9 B! E2 N9 o5 K; u9 Z3 n* j
}
5 `7 a$ p  I0 Z+ o return 0;
' t6 q* d- W2 W' @' ]0 l}4 x  _" x& `8 ~7 a: L
- o9 `. V# p; g) e: Q4 s, c
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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