C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/+ q7 E# `0 @6 M: q: i
#include <stdio.h>
#include <stdlib.h>7 |5 ^* |% |: o0 ]
#include <string.h>: h: t3 o* }1 M0 U# Q: Q3 P
#include <conio.h>, k/ h/ ~+ E# k
#include <malloc.h>

#define STACK_SIZE 1007 G# b! c2 p) l6 R
#define APPEND_SIZE 105 j7 F/ z9 U$ G: I9 L1 @! F) A

struct SNode{
float data; /*存放操作数或者计算结果*/3 G$ n! L. d  [1 p) c$ z. T) n
char ch; /*存放运算符*// l7 b1 n5 e* t) J  _& n5 D
};: J0 ]* [' ?& [
. [$ U# Q4 U2 N- y
struct Stack{
SNode *top;" m" k. A& A7 q" R) J  ]
SNode *base;
int size;/ Q/ T1 @1 V$ v$ E6 I4 I1 j2 K
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/4 e6 J: z9 Y* @! A# ]
int ClearStack(Stack &S); /*清空栈*/3 m& I4 U9 X7 M( ]; g+ U
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/9 f9 ~: t  S8 j! P+ E4 Q
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/; r5 I' T# c8 P! K
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/7 K  ?2 c5 t, a$ Z% @8 ^
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/8 }) z, u; E& ~4 _9 g  }+ U! y" M6 Q
float compute(); /*表达式结算器主函数*/9 P6 d9 m4 ]5 v& u
char *killzero(float result); /*去掉结果后面的0*/ / @/ p' V) P2 n2 J5 W& f5 J: O7 i
0 l* C# j6 B1 Q! D
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));) _: [1 q6 z7 w
if(S.base==NULL)
{4 U3 @, }, i* J' R
      printf("动态分配内存失败!");  c' k* y& @; ^" D4 o8 z
      return -1;* `& ^# `9 N3 D: K# r/ G( _6 ^5 ~
}
S.top=S.base;) `* i5 H; f7 ?
S.size=STACK_SIZE;
return 0;
}! o! M8 y. a3 ?; L0 w

int DestroyStack(Stack &S)
{
free(S.base);2 |# P! g& f* k1 Z% S4 Q
return 0;4 N8 V  ?9 D: G5 c4 ]  E/ \
}

int ClearStack(Stack &S); b) I/ {! t8 g! S
{0 v& N4 h2 j* u- T
S.top=S.base;
return 0;
}

int GetTop(Stack S,SNode &e)# Z% ~4 _2 }( V! |- e2 E+ z
{
if(S.top==S.base)6 e7 ^4 J8 S# S
{
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);0 |8 A; a5 n3 A
return 0;/ G( @9 p) |. M$ n
}
4 C  z- Y/ @) _2 _+ S
int Push(Stack &S,SNode e)0 k) c2 }, C, A# q3 ]& r1 }0 x4 o
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");1 F( ^. A5 X1 p9 c( t: T
         return -1;
      }8 s. \; h  N( p+ E  V/ a! T3 n
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}) s) Z2 q+ c& C6 y/ O
*S.top=e;
S.top++;
return 0;
}% v8 y- }" }. \! |8 n

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{5 m# \. A% V4 J- {0 v. ~) l
      printf("栈为空!");
      return -1;2 |$ ]' }5 p/ A
}- m: L" i0 {! i" z4 W/ Q" f, F
e=*(S.top-1);
S.top--;
return 0;( Y8 J3 u& |5 S
}: Q* J7 g3 W: O3 q
; ]( B* x- G" [# K
char get_precede(char s,char c)6 G4 z+ n* o8 a) u% X- Z
{
switch(s)
{
      case '+':
      case '-':4 r2 x1 ]' ?# V4 \3 Q9 c6 U
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')% q' x" @* T* v5 ^; _, Q# P
               return '<';
         else if(c=='(')5 H) H0 K% L* Q( L( F7 o
               return '<';
         else if(c==')')
               return '>';
         else * u( J" U$ t( L. ?9 u* P" B
               return '>';8 B. \4 T# R+ k. n7 b/ i, b  _
      case '*':2 _1 R' n5 q5 w: e* c+ o; }
      case '/':
         if(c=='+'||c=='-')3 Z- j, f" \+ ?- Z. \
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')* c, t' U9 @1 k: a
               return '<';
         else if(c==')')4 I$ I$ t8 V/ X- b4 E
               return '>';  A' O4 g4 M1 z  c( @
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';3 v* m0 ?3 N- q
         else if(c=='*'||c=='/')+ {3 n, f+ Y$ Y/ x( y
               return '<';
         else if(c=='(')7 K; u1 c6 V1 X9 G8 |0 H
               return '<';
         else if(c==')')4 w; |9 o& F5 E. P, h" C
               return '=';
         else
               return 'E';' G/ }3 V: k* Z  |) K& h) k
      case ')':0 Q, I3 v: _/ q, S+ B' G" `9 G! z
         if(c=='+'||c=='-')
               return '>';( D3 |+ _; Z& P4 d6 j3 |+ q
         else if(c=='*'||c=='/'). ?& o" ^2 F9 \0 B7 w# L( G4 }
               return '>';/ ?/ j. u: x' m6 f' A0 I
         else if(c=='('), R+ a" N2 m& E; w7 I
               return 'E';. ]% I2 l8 t% [4 u# `, a6 i
         else if(c==')')# H6 |" p0 K' _' e. {% O/ z) \
               return '>';5 `9 e  U" z* j! N# Y
         else: ^5 H, S/ _# z% ^/ }% v
               return '>';% M5 N1 f( c9 X8 ]# Q, Z
      case '#':' Z% W% r' l( Y# c8 d3 w% t
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')% x6 l& u2 Z) i  n$ X1 d8 h
               return '<';
         else if(c==')')
               return 'E';9 g0 r" r  u" h4 K9 O+ k/ {* s
         else' Z9 ~" Z) R  v  y8 E
               return '=';- D: I& a! `& b, d! |* h) s1 y
      default:2 v: G5 w) `, ?6 X& L
         break;0 ~1 b, ]# o' g, }, v7 I) M
}6 v: j3 S4 Z7 G% [$ C
return 0; 0 S5 V9 [8 b8 M
}0 G/ c+ G5 \3 r- J* P  z

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')0 q4 [- @% k3 q  e/ |, M
      return 0;8 v% H+ m! u. ~* F
else ( p5 x: {. `. W1 o* T  I" t
      return 1;
}: {  T. W# ^$ l" ]/ B7 @  M

float operate(float x, char opr, float y): q0 }: Q+ d* m( a
{- j; H1 T: M% s' v9 f/ e. i7 s3 p
float result;# T9 w; N7 ^: A; ^1 H! ]4 I" l
switch (opr)
{  G. [# [4 K6 g' d* c1 J$ j' i
      case '+':
         result = x + y;0 q( r1 D4 [. }# @6 |  |- S
         break;
      case '-':
         result = x - y;$ D6 B/ i, N  [) e  s' G( o9 s* m
         break;
      case '*':   q5 ^7 R; d. {' U3 }( O: z
         result = x * y;
         break;
      case '/': 6 x/ `: i8 }  M+ ^# |1 B
         if (y == 0)4 Z/ V$ T( n5 ^+ U. }
         {
            printf("Divided by zero!\n");
            return 0;3 S9 M2 T0 |8 H
         }
         else  w/ I# D& p: x$ d/ }1 Z
         {3 u6 {  B& X9 M- {# t8 H' o. K
               result = x / y;
               break;7 J% e7 o+ v5 `7 c( I3 r& t
         }
   default: 1 C$ K, y. T* S) z9 p. f- ?
         printf("Bad Input.\n");
         return 0;$ Z( l2 e- d; x; @7 I% t/ A4 |) b4 N
}& B) a* J2 q  X
return result;
} 8 t' x! D& f) n4 m( t
: k. b6 K6 P) T2 p2 r" m$ F
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{$ D8 t: W. P6 ^- O( d/ F* @/ t
Stack optr,opnd;' i1 J6 g5 n1 a& x
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;% ~- P- n/ P" O& X
char buf[16];4 |4 y6 }. t( r; ~. N. y: s2 Z! {: m4 _
int i=0;
/ z: S# z2 A! R# E$ e
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));1 U. ?9 `1 Y' i0 Q1 Y8 S! k
( w9 \- Q. S3 O
printf("Enter your expression:");
      $ d* e8 ]/ U9 Q
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);; |7 P  C8 |7 n2 e8 {
c=getchar();6 D, d4 d9 n$ }4 [% g
while(c!='='||opr_top.ch!='#')! s# C) F+ A  V9 c
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/: a8 `0 @# ^5 d6 B: A- U
      {
         buf=c;; l; k& u. r2 Y7 x6 D2 A
         i++;* z) ^4 W5 y& M" _7 G# O
         c=getchar();
) C1 I' W# H5 ?; T6 k0 N& G       }
8 X! [0 ^) v/ C; V- j       else /*是运算符*/
; c* _- J/ a+ b       {% z5 r7 p+ `" T! Q$ B' i' G
         buf='\0';
, U  W, o' W: `          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
+ @' z, ?; _4 R8 s) H          {
& V, M5 U" H6 a- M: G2 S( S( i                opn_in.data=(float)atof(buf);
; u* C' m( E( U$ W                Push(opnd,opn_in);
# W+ z6 q! g0 T4 c  v                printf("opnd入栈:[%f]\n",opn_in.data);# E; A  n5 g" y; M! ~
               i=0;
# t7 {8 C+ m0 t' w, q                memset(buf,0,sizeof(buf));
# U4 g4 `4 [$ Z: x; l! I          }: B/ y" O$ d7 }5 B% `
         opr_in.ch=c;' M7 ^' N5 e' e2 _# d
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/: P# u$ f& R1 o5 d' M* v7 R; g" Q
         {
& L* p9 w7 n* j             case '<': /*优先级小于栈顶结点,则运算符入栈*/: u8 s- S1 R& j+ Y) x
                  Push(optr,opr_in);, K" j3 t0 a/ ?9 R% [! m; D. c
                  printf("optr入栈:[%c]\n",opr_in.ch);& U4 C, z3 \) U  K3 {; y
                  c=getchar();. I/ O; `, R6 e5 R7 f! T  Y" k+ d
                  break;
6 S! U! m# o: ], d9 W/ T0 [             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
6 L- I) c6 V7 V2 V                   Pop(optr,e);
* [% u( T. P+ z+ u$ t                   printf("optr出栈:去掉括号\n");
3 O/ H4 |6 W2 R& I  T- ?                   c=getchar();) R& q/ f/ A  u4 A  P
                  break;/ I$ `0 l3 K! _2 h( V' f( N
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
6 F4 X2 A! W/ ]( s" o                   Pop(optr,opr_t);
4 D% \/ y! Q! M0 s* m                   printf("optr出栈:[%c]\n",opr_t.ch);
( |1 I, u$ ?- Z0 }* f. Q3 T1 Z                   if(Pop(opnd,b)<0)
! W* d8 D7 |' g/ I3 \0 Q! U! L                   {" g0 I! r6 P- o1 f" K5 a& [! x( N( l4 }
                     printf("Bad Input!\n");7 w" Q: ]2 o7 z& o; {
                     fflush(stdin);
6 V: b$ ~% x6 o" U& @( q                      return -1;- Q9 q- ~* a! u( E& v' p
                  }1 R; g" A! J* K' R! e
                  printf("opnd出栈:[%f]\n",b.data);" w# u, H; r2 P( p4 t( J: q+ n2 J
                  if(Pop(opnd,a)<0)
- u/ B+ l7 \. z( ^2 b, r' W/ A9 ?                   {- d+ y6 |% _( Z; S
                     printf("Bad Input!\n");
; Q# T1 h: X0 _  Q                      fflush(stdin);
; q2 b5 @  f8 I) l' Z9 c: m                      return -1;
! d+ i  B4 a- F( U1 o3 f                   }
3 o1 N. G" p) V( P                   printf("opnd出栈:[%f]\n",a.data);2 p$ z2 G( E4 Q; _# `/ G+ k/ @
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
9 ?9 i$ Y3 G) t# u                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
0 W& @+ \6 F5 o; A; n                   printf("结果入栈:[%f]\n",opn_tmp.data);
4 s2 Q- ~8 N; P$ ]# f9 K                   break;9 ]8 {/ m6 U) [, f. r$ b7 ?
         }
! Y, A. [7 `) Z) Y0 C       }
  d& N' s+ u4 u  X- ]' ?3 p       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             + q9 L; F/ _3 h! [! j* @! ~
}
8 y2 J6 }. E  Y: B& P GetTop(opnd,opn_tmp);
, x& \3 q# m) L7 v9 [ DestroyStack(optr);
  x6 T  f: V/ P DestroyStack(opnd);
! x0 l; B: V& Y# O return opn_tmp.data;
' Y" h- M9 a: V% G}- k+ j+ ?( m& \

+ j# W- a( S- p' dchar *killzero(char *res,float result)
2 m3 b8 _0 ?6 i6 K{/ u% w! M) n6 ^0 Z% t; k( }
int i;9 i( E0 I/ c2 x0 o  e- C- c

% ]/ z) `0 t& {4 N# U% X$ Q2 p sprintf(res,"%f",result);; W/ m- U4 G$ V7 T9 C. B
i=(int)strlen(res)-1;
: x7 _! R: U* b6 o while(i&&res=='0')
! M5 Q2 W1 o! X( H, }1 N/ j {
/ J; t% V, _. \) ]0 z' J       res='\0';
" ?' w% w9 c; v  u9 c       i--;7 n" h  u; s. N) L. O
}
6 O7 P) z0 `/ y4 R; ~) o0 p% z1 g& E if(res=='.')
  Z$ i0 b2 I' f9 ~7 |- ^8 P       res='\0';1 y& i9 P; F# E5 T- c
return res;
9 P" S+ `7 i- }; C) N- L8 B7 b* s4 w}& P3 f9 f& y  v6 e

5 l% @( g7 T7 ~4 C1 A- C1 G& \int main()3 J1 \: u8 ?5 @' ]& F1 i' ^' v
{
& n- J0 P+ f- s( S8 P, @+ V' }- x char ch;. }  L  y- n% z! Y8 s7 {% K
char res[64];
: S+ Y( C+ F! O1 Y& w: E# N& g float result;
/ e+ L" l& J7 L$ m' z while(1)! V) j& @6 p6 y) o( w2 Y  e' R
{" B1 s# E: x# v( I# M( R
      result=compute();' }9 y: w) e1 I7 i7 E3 K1 @4 A
      printf("\nThe result is:%s\n",killzero(res,result));
! ~$ |  [! C7 X0 J       printf("Do you want to continue(y/n)?:") ;
- U% g' u# o. @, G! m       ch=getch();
- q; M/ z4 F5 C2 h/ m; G  t       putchar(ch);# D* x# x) `4 _, H$ ?/ L
      if(ch=='n'||ch=='N')
6 N! {1 l0 u; \5 [          break;
' W8 ^$ ~* a  O+ i       else
         system("cls");/ w- n: _# @: ]- A
}0 u! b- Y/ m2 O; e: E6 Q
return 0;
4 O6 n! x8 Y5 T5 I$ ?4 K}
( G- B* E, F  [# l
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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