C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/1 h7 G6 S6 b7 C% G8 u8 E
#include <stdio.h>
#include <stdlib.h>3 i8 J* f: C' D% _1 I. W* d. i
#include <string.h>' O" D& c( G9 f! ?2 F' w. b. q; U
#include <conio.h>& _0 {, N; I3 X% R! `9 n
#include <malloc.h>

#define STACK_SIZE 100- X& d( h# P4 I; A" F9 [
#define APPEND_SIZE 10& M" m& X6 Y" @2 B& k& E
4 E, v0 Z4 h6 X# n4 n1 q+ S
struct SNode{; I& ]3 @( R! \9 x0 b  L
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};
/ Z3 R: v+ l+ k6 j
struct Stack{5 j6 f% q1 P, y- x
SNode *top;
SNode *base;
int size;
};  s: ]2 d8 p; V( b" i) j8 B
  Z" t  v$ T9 N3 l! X/ Q' m
/*栈操作函数*/% L$ L& C7 P$ f6 ~1 b
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/% e* F5 v; X' x# k
int Push(Stack &S,SNode e); /*将结点e压入栈*/% e. h) [9 w2 z; [' E
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/& N, _2 O3 c& R: X

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/3 C9 y+ j: [% z# l6 f
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/   P% \( ]/ Y" n: h/ x
; H: [' L' V: K7 G- M0 U' o4 ~$ f
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));0 q' U! V; o& K5 L# [
if(S.base==NULL)
{# C' [# {9 Q* F( ?! v& Q
      printf("动态分配内存失败!");
      return -1;. p8 u1 m3 q% I1 d
}  `  g0 j# ]2 G' E# ]
S.top=S.base;
S.size=STACK_SIZE;8 z9 {( g; f) z2 I; ~
return 0;* X1 y/ E, Z3 P* K7 Q9 ^7 b
}- V2 @4 v, F" q0 D) o

int DestroyStack(Stack &S)
{* ~: G7 ?6 ?: f1 Y
free(S.base);
return 0;, ^* k; y/ d4 r! E
}" ~; }4 w4 X2 }6 X5 U

int ClearStack(Stack &S)+ w4 ~+ |% P* ~4 h$ Y  V
{
S.top=S.base;
return 0;; ^; b8 m% ~! s8 D9 }$ C1 T
}
/ P, [, y0 U) m
int GetTop(Stack S,SNode &e)
{7 S& A' G; W0 S: Z% V" `4 h
if(S.top==S.base)
{
      printf("栈以为空!");% S+ ^7 }$ t/ Q) S/ D6 y
      return -1;
}
e=*(S.top-1);6 S/ X' t& z% ]6 z
return 0;' O6 d" |6 C* W
}
4 h+ {6 X/ I( ?/ I' V4 `
int Push(Stack &S,SNode e)9 y: Q$ v# n# d! Y$ q
{" {' F# Q3 m8 M* O9 H
if(S.top-S.base>=S.size), O( P4 \% y" K9 P
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));; o  S/ F/ u0 H* {8 w  J# {; \! L
      if(S.base==NULL)
      {9 y+ r, g% B  W
         printf("动态分配内存失败!");
         return -1;. D. W; b% Z5 Z' x4 i3 ~
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}, A1 E- c# t: U8 `
*S.top=e;" f' F6 r! R* J( e: \/ z
S.top++;
return 0;+ g/ s- l) s* O! l- I
}

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)' h; M7 F6 D" d3 G0 ]+ W4 Z
{
      printf("栈为空!");% F5 |% V: h: F. K
      return -1;. k$ G5 N$ X9 d& ?5 Z
}
e=*(S.top-1);
S.top--;
return 0;% l3 \3 ~1 b6 `% L. ~
}
5 x7 A. g9 S$ U; B- ^0 O
char get_precede(char s,char c)8 ?/ Q! V7 \. D5 I) w
{
switch(s)# g' p. j( F0 D' {1 [; p( F  r
{: p0 X: l# w! }
      case '+':                  |. S& h3 R' U" Q. v  X* {" m* O
      case '-':2 C0 C* M( _" q; d. }
         if(c=='+'||c=='-')) q4 ]8 a: K0 \2 f) X* A
               return '>';! q( V2 T4 m& Y. U3 |1 ~
         else if(c=='*'||c=='/')
               return '<';! H# ?) j& H7 E% S$ y
         else if(c=='(')
               return '<';4 b) }4 r0 Y, P; g
         else if(c==')')6 h: M; `8 l. y2 `$ B. [
               return '>';
         else
               return '>';
      case '*':
      case '/':' @/ @# Y8 Z% U* [
         if(c=='+'||c=='-')* z% \9 `. l7 Q. ^
               return '>';: T' |7 T. S, L# w
         else if(c=='*'||c=='/')% G. C  S- f. J. d
               return '>';2 ?5 O: M% ~) ^9 w5 j7 n3 E
         else if(c=='(')) ], N7 X* C2 @# \7 C3 e0 {
               return '<';  z8 @$ x( ~+ L/ r/ p
         else if(c==')')$ r0 |  [# K7 p# A/ a" O, q9 c
               return '>';8 q& x) A0 u/ f' r: h! ^" W: E
         else
               return '>';$ g& s! E; L. @: v: f5 l' X- ]# O
      case '(':+ C5 Q# g* h  J8 T2 ~
         if(c=='+'||c=='-')/ O" t! S& O" a
               return '<';
         else if(c=='*'||c=='/')
               return '<';6 n9 a9 ?6 z9 m1 \' I' P; @  Q5 p
         else if(c=='(')
               return '<';
         else if(c==')')7 c4 [0 S4 B( D0 p
               return '=';- a3 r& u2 u9 S8 c* t2 G/ M
         else1 k" |9 K( d+ n" N, g+ j( G
               return 'E';  {/ X+ m/ O7 Y7 \5 n  R
      case ')':/ D9 P  F6 p6 j5 W! S; P2 E
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';; l5 r+ u) H  E/ P8 P# k4 B
         else if(c==')')
               return '>';" ~4 _& Y2 E% E% S8 d! j
         else( R6 D7 d4 I" T: {0 w0 W( A
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';1 B& R  v; E" J
         else if(c=='*'||c=='/')
               return '<';' b) `& l  Z1 n; D1 u
         else if(c=='(')' G7 F0 S( B: B8 U+ W% Y0 a2 B
               return '<';
         else if(c==')')2 r1 r2 k: J. f- B% }
               return 'E';
         else
               return '=';
      default:' I, A) T4 }8 ]% h- B4 {/ o; r- S0 L
         break;
}
return 0; 7 Q. P. V; X/ w) k9 s2 ^
}
- o0 B) D5 b+ g( [; P2 j
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')9 z; D, d/ ^& y1 F6 I
      return 0;
else
      return 1;
}3 g7 Z/ H' F* u
9 a( N1 P) ?+ ~! Q
float operate(float x, char opr, float y)
{" b, D" g4 P, E  h
float result;
switch (opr)2 V. [. n: J9 W+ r
{- i. e+ M$ X  d! j* E( `2 U
      case '+':
         result = x + y;- H8 i2 G! N7 R4 O3 Z" t
         break;9 p7 O( K* R0 A" l  E$ X- K0 F
      case '-':
         result = x - y;2 m6 z) ^7 i5 T5 |
         break;# E9 N  u! x! T" I: d. X5 U
      case '*': 5 b$ }: w* T+ @8 L. o0 ~* `
         result = x * y;
         break;" C$ K* I; \3 E) \
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");+ ^( z& B; q% l9 S1 e
            return 0;
         }$ R, x, @9 g. K$ w( [( S
         else
         {+ \0 k5 p; U! f5 }
               result = x / y;
               break;
         }
   default:
         printf("Bad Input.\n");
         return 0;# Q0 W% ~- a" K6 b
}
return result;; g5 P6 r1 H9 O9 E) Y# o1 ^2 |
} + s* v) G& ?% H8 P9 n- H
% k2 M8 C  V1 V4 V
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;/ M$ r0 [' B/ l! ~
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;# _6 `+ X% M: _& h+ u
char buf[16];
int i=0;! N1 C) z( C: O2 v5 ^4 f" t

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/+ k6 o4 \) g% k2 x4 I
      {, \" A+ M+ {2 p* u2 |
         buf=c;- }. J6 B, t* M$ O, J0 w0 E. V
         i++;
1 s) d# i0 E8 ^& k% t9 d) p# A' l$ l          c=getchar();
8 l- V# \, `8 X* A, b/ n       }: b  p6 c* X- Y3 q* [+ N
      else /*是运算符*/
& X; N; P- G. o5 v" \& G       {
. n+ C5 M& G* H8 u, Q" S          buf='\0';
$ Z+ }( x# M" v+ F6 q          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
7 ~# N" ^/ \6 q6 }          {# r- j! {$ T4 x# g* m. d& \2 M' y
               opn_in.data=(float)atof(buf);  j  l2 E6 |/ ~1 h) K7 _+ J0 V
               Push(opnd,opn_in);& I. U8 i2 j6 m* b4 z
               printf("opnd入栈:[%f]\n",opn_in.data);( ?3 ^" Z2 }3 X8 T7 W
               i=0;1 ?% K* x" v; {/ x0 I5 G: X' v
               memset(buf,0,sizeof(buf));' E; X  G3 t' q7 W2 o  B
         }
  o+ |/ a. e4 }! ^          opr_in.ch=c;. J8 r7 T" |2 @1 q" @
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
# ?' t* _3 v7 H& M# I          {
( m& M! O$ X5 }4 D. R+ d' D( t6 V             case '<': /*优先级小于栈顶结点,则运算符入栈*/
4 x3 d1 G1 i# [  e, [                   Push(optr,opr_in);
& |$ M' i  ]! y1 g9 Q                   printf("optr入栈:[%c]\n",opr_in.ch);
, f  r$ l) N2 q                   c=getchar();3 j' A$ x# n' q2 k8 f
                  break;
3 z& l3 c* \5 C             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/5 n. N7 S$ q: |& v# ]* D
                  Pop(optr,e);1 c0 P! G3 R  D% e+ `
                  printf("optr出栈:去掉括号\n");: D7 A5 u& c( X8 l
                  c=getchar();
; q4 D: L. Y. E: Q; d                   break;
& s& g3 b# ]2 r$ A: O, G             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
3 g, |! K5 J& ^+ N0 s) _* A1 b8 K7 t                   Pop(optr,opr_t);
! u" B( Z) A$ k2 c                   printf("optr出栈:[%c]\n",opr_t.ch);/ Z- O, N3 |: M
                  if(Pop(opnd,b)<0)
  Q8 v. u4 _- s, i# a! \                   {
% I" L* _! i* e0 }/ v3 z                      printf("Bad Input!\n");
- H0 a  `: c9 ^6 Y                      fflush(stdin);0 a1 N( V( y8 a
                     return -1;
- C4 ^- k% }% G; l8 y* [) C% I                   }4 P# r# O' b# t' @) h3 g5 p- J
                  printf("opnd出栈:[%f]\n",b.data);
) Q. N, l8 @! g5 h% ]                   if(Pop(opnd,a)<0)
1 w2 b. m2 O1 z& j                   {& r; X! q- C- a2 G- Q
                     printf("Bad Input!\n");" R0 P- K7 w/ z
                     fflush(stdin);2 Q8 s# n3 u, F
                     return -1;4 ~% w" P: l% v5 B( E; D$ _9 T
                  }0 |# [0 u" V4 f2 }' J4 \
                  printf("opnd出栈:[%f]\n",a.data);
! A3 g7 a) q6 g3 @% @& k$ w& W                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
8 x, O  [+ Y3 @+ S  }9 h                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
( {0 ?" [2 G& \. B( _3 }: X                   printf("结果入栈:[%f]\n",opn_tmp.data);
1 V  q: Z) [* P1 e) p" O                   break;. ~* x' V2 v. s! p3 O% [
         }# M; d/ G, c! j; G; X( K
      }" P" j+ r% e. [" U
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
& U$ ]+ O% w4 J5 E }( O: n9 X$ f, n) X" ~
GetTop(opnd,opn_tmp);: }4 ]! F+ y7 t5 i0 e6 M
DestroyStack(optr);( T" |7 S7 }; O) I
DestroyStack(opnd);2 K/ @) Z" i% L) z" O! X( L3 z
return opn_tmp.data;
5 T2 Y0 G* s  ?. L- y; y+ w}# h! q& N5 v  i, E& `4 l

5 H5 o# p6 ~" z' k- p6 uchar *killzero(char *res,float result)
1 C, U( i# [* M* f+ l! O9 Y{# ~& a3 c  n: o  }6 J2 Q
int i;, j/ }$ N' A7 J) ]# l. @

- P- B: T+ B" S sprintf(res,"%f",result);
, @9 L$ o) w& h. V" s1 S7 T i=(int)strlen(res)-1;9 M' z; _: A3 I# `4 L
while(i&&res=='0')
4 T, |& u! n! m1 W9 Z, }  u {
% W; }5 {2 D9 [+ D& c+ M       res='\0';
# H4 i( Q$ \( M1 u0 @       i--;
) h1 i3 d8 s- y% ^ }
8 \* Z% s$ x& Q) ?/ `( R) C9 P if(res=='.')
% ~* n+ Z: H6 p! v& p; Q       res='\0';& {* E$ K, V/ Z
return res;
. t2 ?& [+ g7 i$ c" ?4 a/ M}
" Z: t7 f7 H- W8 q5 ~/ [9 f* }; k$ d( B! k% W. r4 x
int main()$ ^# y2 O$ K7 q7 O7 E/ A
{: I" H2 l0 W" k3 D
char ch;
- `0 {$ n% {- }# ^ char res[64];) k% g. m8 c& O! Q4 E% z
float result;
+ ]0 S! F2 N& h- h! W* ` while(1)
1 e7 m0 Y! c! U$ o {6 s2 w9 j; B) C4 P; W) p
      result=compute();
  s7 |" ?# m1 I9 i' _. M) t4 @& m       printf("\nThe result is:%s\n",killzero(res,result));
8 j6 ?" P+ E6 M9 Z- ]( w$ U0 k. h       printf("Do you want to continue(y/n)?:") ;
6 y" l( h7 M; y6 Q7 M; V       ch=getch();' f& F1 x" W2 w4 h/ @
      putchar(ch);
9 m9 t( O9 Z: ^* s' f       if(ch=='n'||ch=='N'); T3 d" ?4 R! z2 h: l$ J
         break;. [, n$ E; J% B5 f
      else6 X4 q( I: Z- u
         system("cls");' z5 ]8 b6 S2 X$ c. \: V
}
/ p0 w2 F: l( M return 0;
( t  P8 O8 d; B4 U5 b  [. w}% Q: @5 b! {2 \# p
1 |$ `, t+ V9 h1 s
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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