C语言表达式计算器

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

#define STACK_SIZE 100
#define APPEND_SIZE 10
& R6 d" G" k; R! B' O- M
struct SNode{  _& v9 J# ]$ @) q: x
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/- R' p: {- E; D3 [
};* f. |" T1 v$ h' d3 k( x, l
( b( p3 _2 z$ Q1 `# @
struct Stack{
SNode *top;, u  X( P7 T% l, m, Z5 ?/ O
SNode *base;8 F3 m9 ?; u  a  e2 j7 s
int size;$ @. C* R* u% Z4 u9 b' n& w* s
};# J5 s* o8 F- H1 T/ Q( i
1 ^! T5 \* X  H, Q1 q
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/( n. `. X8 ?' F* t3 J  W; X
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
3 g  S* n. C9 j- q8 Q# k
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/- Q8 h9 t: f) r( W
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 7 J) G9 e- V3 @: t

int InitStack(Stack &S)4 b1 C, ~4 X# V. [. C0 |3 h* r
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));* n( z- X9 x: ?2 @
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;% R" A) K* z' \4 [
return 0;% I: d% V! w) j1 Y
}

int DestroyStack(Stack &S)
{( l! O2 D3 }- }2 Y
free(S.base);
return 0;5 I  z" B: L) N) @6 a2 L
}

int ClearStack(Stack &S). y  R% T( A' [( g
{
S.top=S.base;
return 0;! |" y$ R9 L4 @: V
}2 y4 ?4 a1 t  L/ r, m" p# R

int GetTop(Stack S,SNode &e)3 y2 r9 [/ [$ P0 o1 q  A4 r$ r
{* p& Z% f+ ~4 [4 O/ Z- g
if(S.top==S.base)' g: A6 E: D& b7 o/ j8 ?
{
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);
return 0;: b+ ~5 G9 C' h; s
}

int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)/ {  Y' B% O0 z4 ?
{% V. [2 U# t) M- y
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));* ~* ~2 w1 O, R0 c$ F: ~( `+ N
      if(S.base==NULL)" u* J7 A7 |) N. L. K
      {
         printf("动态分配内存失败!");
         return -1;
      }/ G6 V1 x2 C2 v: {: N) a
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;5 R9 S2 e8 I# V4 \' E9 ^; t& ]
}7 ~. R% y4 D1 p, D5 H0 }4 M0 `' x& \
*S.top=e;3 ?! u/ X% T: f3 W( p
S.top++;
return 0;6 ?# B8 A% l4 U6 `
}: n- `1 g. T3 Y0 l+ b2 T+ f3 V
$ r* O3 B1 \7 [2 j% ]
int Pop(Stack &S,SNode &e)1 M+ I" j9 v3 @, b, s- n
{7 d& V5 B3 |6 c$ g' s
if(S.top==S.base)
{/ F- f6 f3 R2 t6 P. V) o) h, y9 r
      printf("栈为空!");
      return -1;; \2 @; C* R  E. W3 P* v
}" S; w7 u. a) w& a
e=*(S.top-1);
S.top--;
return 0;
}

char get_precede(char s,char c)
{
switch(s)
{
      case '+':                ; k; h! J. ~1 p5 c3 W% {
      case '-':7 k' ?. y& f5 o7 b
         if(c=='+'||c=='-')
               return '>';: N8 r9 g+ L* q1 g- k6 v8 j8 [
         else if(c=='*'||c=='/')# q* V4 e" g. R5 j; K+ N
               return '<';' c7 N7 [+ `  B8 n
         else if(c=='('): R  d* v4 M4 ]" S4 v
               return '<';
         else if(c==')')* H. w% N$ w* Q% U$ ~# E" q
               return '>';2 k# @! [2 d+ z* G" z
         else 3 g8 I. ]1 g; r1 q. t
               return '>';' c, C, L$ t5 v" H
      case '*':, n! H4 s4 W6 N5 g
      case '/':7 W: j& j0 W8 E5 |  A0 h& b6 H* T
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';- @9 T" N& t9 \
         else: [  ~" X  n& ~, z) U1 x
               return '>';
      case '(':, b) J7 Z. c+ k3 ?
         if(c=='+'||c=='-')& v: H8 e4 e4 S# H8 s2 }8 z, w
               return '<';5 T. U3 u3 W$ a  O- K- m3 I4 ^* w
         else if(c=='*'||c=='/')
               return '<';& N- S, Z0 I# _- G2 v3 m
         else if(c=='(')6 S. \* e; m/ K4 m  `/ O
               return '<';
         else if(c==')')) `! c5 l. o5 u" N
               return '=';$ |  z# [3 _1 b/ r: a! \1 ]" l
         else1 ^: W& n8 A, j: |; N3 ?1 u6 n
               return 'E';1 c' q) f0 l0 F
      case ')':8 S) ]( ?- _) I4 u* e0 c+ {1 q
         if(c=='+'||c=='-')
               return '>';  W2 r# H! y! d; Z
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')! ]  x- X5 ]" |1 D# K
               return 'E';
         else if(c==')')
               return '>';$ I5 |2 x3 }7 a) _1 X& `7 g
         else* C3 U5 J  v9 G; W) \* a
               return '>';9 h7 J% G# Q0 R  X, e( I) ?* A+ J
      case '#':% w! ]* l) c- |4 ]
         if(c=='+'||c=='-')
               return '<';/ e- j8 R- S" }; S% w! c: I1 Z3 x
         else if(c=='*'||c=='/')7 C/ W* n0 N+ A( D) k) C: R  \
               return '<';0 p1 R% n" b* f
         else if(c=='(')
               return '<';
         else if(c==')')
               return 'E';0 f  o& W/ e  [# Y% K; o5 i
         else9 f7 O( D) z1 R, c/ s* ~( I- c* j
               return '=';1 {1 y- e" u! Z
      default:$ I, Q5 u/ S3 B$ W8 k& e
         break;+ s- C' w1 T7 `# Y1 W4 z
}
return 0; 5 U- o) r4 k' j5 p+ C
}- c0 F" R+ D$ O4 `) o( j/ c

int isOpr(char c)
{: b$ x7 Q0 x: B' m) B
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')4 |5 \. O8 {. Y& _6 Y. K
      return 0;
else # w% h+ P3 l: B8 Y+ k
      return 1;* M7 H4 i) w$ S* G* H. F
}

float operate(float x, char opr, float y)
{
float result;
switch (opr)
{( w$ ~: Q+ n" `$ m
      case '+': % }5 h& I' e3 w. X" V3 o
         result = x + y;  \+ U7 u, b9 C$ l
         break;: O/ r5 p  }5 c* J9 `
      case '-':
         result = x - y;7 b8 i" h% X# B+ l3 T+ \
         break;, ]( w( [$ C! B9 _, Q; i
      case '*':
         result = x * y;, {% q9 M" X( ?) v
         break;
      case '/': 8 \# w+ D; ^- ]$ N: E$ s. `0 J( ~# t
         if (y == 0)7 A. ^$ Z: |0 |) h2 p
         {
            printf("Divided by zero!\n");6 |3 J( W: D& d& [5 }( E
            return 0;
         }
         else; v; o6 f0 L* r+ f( x2 a
         {* q" r( A' u1 Y1 ^( S% `* ?
               result = x / y;4 O& |0 N" i/ n9 f5 K
               break;
         }8 t# T& C+ L+ h
   default: 7 Z6 H9 P) r6 C
         printf("Bad Input.\n"); . |$ _0 `1 }! [9 I# s4 B
         return 0;
}
return result;9 w0 l) P7 M; J9 |$ V0 q6 F' P
}
" n& ~8 p( `0 X+ x
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/8 W: o: M% X! K( s$ F
{, P5 y! j; w  C8 h7 H# f  m
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;
* W5 K* Q9 |- G" r; M) a. b
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/! ?# J2 q, ^1 D- N1 U6 r
memset(buf,0,sizeof(buf));

printf("Enter your expression:");  L5 M& [  f1 D3 @- h0 v8 R
      0 o' M% o* v- }. E, R
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/! X; g$ h/ ?6 v0 N. z6 l
GetTop(optr,opr_top);: w7 E, J+ W% _8 ^- s1 R* l
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {% K& Z. W+ L( Y
         buf=c;
  p% s& u4 F# }& s+ ^          i++;& k0 N9 |& a: ?. s, S5 p
         c=getchar();9 `$ A/ d  S6 J, M' ?9 J+ Z0 Q3 p
      }" J* a1 i0 p) n$ Q( _, s# `
      else /*是运算符*/- j0 M7 s2 J: q
      {
* s& D# f0 t% [8 b8 W) R2 D          buf='\0';- D9 z  y. y9 l* b
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/7 ?* V4 J2 O. q/ q* q
         {' o: A7 I! R1 n
               opn_in.data=(float)atof(buf);5 T4 \( Z+ S$ w$ d& j7 F9 ], O
               Push(opnd,opn_in);
5 x8 V- x% a2 R7 f% M2 a                printf("opnd入栈:[%f]\n",opn_in.data);
* q" _: Y1 U/ \- Y& Y- Z" P                i=0;
6 X5 B  ^( M# }                memset(buf,0,sizeof(buf));
- J. w0 m! A4 a" |' T! E$ }" A          }: I% X/ A# G0 x+ M: C6 k+ L
         opr_in.ch=c;+ U8 M, M6 C# Z9 @" N9 \% @; Q
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/4 w' F3 c' o. x1 z6 K" i1 g$ E
         {, B+ v6 K% M! A2 O0 G
            case '<': /*优先级小于栈顶结点,则运算符入栈*/# H6 Q! a: i9 t; R2 n7 E
                  Push(optr,opr_in);
* ?% `% x" x" w0 z( s2 r/ o4 C9 l                   printf("optr入栈:[%c]\n",opr_in.ch);
6 j8 U. k  N# _/ ]% L- C& ?                   c=getchar();' Q  l+ T# f, ~' w+ z# ~* w
                  break;/ p1 t5 l3 s( x  u9 P1 c
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/1 a& E! ~/ x' t4 X% t
                  Pop(optr,e);
2 f7 a# ^# U/ @$ R3 m6 s                   printf("optr出栈:去掉括号\n");
6 o5 g8 c/ M3 N/ Y  l7 M0 U                   c=getchar();
& `3 s: E) r- s: {! M/ P                   break;
- S: l% \  s( ^7 _             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
$ q- ]9 _2 x+ a0 q+ H* V                   Pop(optr,opr_t);1 x8 P- x, D8 b
                  printf("optr出栈:[%c]\n",opr_t.ch);& J( E. r. E) `5 }$ R
                  if(Pop(opnd,b)<0)
- O: p! i3 l# |& T1 b; v' m7 b                   {
) M# P) I1 c* ^; `                      printf("Bad Input!\n");
3 }, r( E* I* w- ]5 e+ _. x                      fflush(stdin);: v5 [4 C7 U& N$ X
                     return -1;
6 s# K- R! W1 O# Z2 B1 i/ G                   }/ {  \1 K* ?* p+ N( h
                  printf("opnd出栈:[%f]\n",b.data);9 f* M9 [- h1 _. c  G+ z- K
                  if(Pop(opnd,a)<0)
% Z! t- k3 E: w5 x                   {  X" e5 H% |+ u, i: c! x2 Z# h
                     printf("Bad Input!\n");
' O2 i/ M- f* ~6 e                      fflush(stdin);
' r0 _2 p6 D$ s  F' n                      return -1;' T9 m7 d6 t7 X$ L3 j' ?
                  }. y1 n9 n9 R4 l+ D6 o1 j
                  printf("opnd出栈:[%f]\n",a.data);) L0 Y% l3 [, P
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/, f5 H( p( x+ q& O
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
0 _% u, E, N* w  C4 E! e                   printf("结果入栈:[%f]\n",opn_tmp.data);
/ ~( e& Z& d- c& S; T                   break;
: B% B7 w8 b5 w1 F3 @" O% o1 ^# ?4 K8 K          }% S: E, b, D1 e3 I$ l
      }
% ?" R/ |! l/ H4 m# ?* r       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
* ~3 j& n- }6 t0 L( @/ T }- \. ]% @, S8 R4 @. M0 b" C
GetTop(opnd,opn_tmp);3 n2 j& }$ j# V# m  M9 I9 N2 c* o. Q
DestroyStack(optr);( ?% G, t8 ~& H' b4 W- ~
DestroyStack(opnd);
2 f1 o  [. i$ R: M' I1 p" q7 J9 B return opn_tmp.data;
1 f( }, R. P3 ]' H3 R% p}9 t! ?# c5 L$ y$ \
+ y4 m+ ], r) j4 N) }
char *killzero(char *res,float result)) \( O# G$ r1 z5 C: H2 Z7 @
{
" N1 ?2 I) A0 t  y  {/ P6 v int i;+ p4 c2 a; z9 q

* m, O! D0 J$ F9 z5 U5 U% b% d sprintf(res,"%f",result);
4 f% P6 B8 L! r8 b2 x i=(int)strlen(res)-1;
1 l/ y$ f4 U- O* Y- k while(i&&res=='0')
3 z3 t0 H# }8 [, A+ H {- u; d# C7 y. S8 A) p* f
      res='\0';
' `  ?* c; e) K- y: P       i--;4 a; z) ]2 C$ Q. [7 g# T5 P1 @
}
  e0 G9 z) d, Y! y" ?7 O4 d3 r, N: T if(res=='.')8 v2 S' ~/ f+ ?4 L4 |2 r6 E
      res='\0';3 m: Q6 k$ y- e( g8 \$ J
return res;  ^( Z0 L" W9 F4 C9 [7 N
}5 O0 Y6 E0 J  y; V

( }+ p4 C4 c- l. d! Eint main()
5 Z' B# e6 B6 a; w+ f0 N{+ j2 ?" A4 T% |. `4 L  Y( [
char ch;0 B  e3 p& d2 x: I$ Y' w- Q
char res[64];
8 B5 E8 \5 ?" s/ L- `( k+ p float result;
% A; L1 a, l3 y* a9 G3 n( I* Y while(1), e3 F8 v5 U4 D; p
{
" z% B  I  I/ t- I& T       result=compute();
/ V4 A9 o) r) {& K! n       printf("\nThe result is:%s\n",killzero(res,result));
5 E' @1 k* L- J4 ^, H       printf("Do you want to continue(y/n)?:") ;
9 g9 F& v" |2 S: C- B       ch=getch();' C+ w0 K! D1 H$ U
      putchar(ch);
7 A) M1 N5 W1 _0 B1 n* q3 x0 ^       if(ch=='n'||ch=='N')/ h0 M4 j' g0 f, C; r. p' ]
         break;
0 U; v  s8 d' k( L+ M; W       else
5 T; ~' q4 m+ P, }2 _          system("cls");
+ @- Z& C8 ~$ C$ v; h! _, U/ l }
7 W( M. |: w0 D1 ]" l. Z2 J return 0;) D. {, ~. A+ f( f6 l2 l2 \  ?
}) d0 t% ]9 _0 f9 j0 ~

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

返回列表

C语言表达式计算器

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

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