C语言表达式计算器

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

#define STACK_SIZE 100' \0 ^  S* v: R( k2 G
#define APPEND_SIZE 10

struct SNode{1 i1 i: f% j& I
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};

struct Stack{
SNode *top;6 F! m0 h3 i+ z9 J. _
SNode *base;
int size;
};" p) b1 }6 {  q
# n) n; c6 M/ \- U
/*栈操作函数*/+ F+ [& p2 g9 h: \" [% P( w
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/) @: Y5 x1 d" l* j
int ClearStack(Stack &S); /*清空栈*/8 z9 F/ X5 N! O" m- W9 n
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/9 x  L" @8 F# a0 z2 d* G; j7 ]- h. C/ @
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
0 {6 p! s6 H# [# ?- ^% ^& O1 P
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/8 a; p0 |7 }( o% ^
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/1 G- z/ p, o5 f; f2 P7 j
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 5 w% l+ M% a$ ?
$ k% h/ V7 N+ c' h9 D$ Z- ?9 T, v
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)7 m& l  m; \. t6 T- s( V
{
      printf("动态分配内存失败!");5 Q" J: a. O" o5 Q) n
      return -1;/ s6 K& r- b8 ?2 j$ c/ H0 v5 k
}1 z+ ^7 ^, H, S, j4 R* Q
S.top=S.base;
S.size=STACK_SIZE;
return 0;
}2 t) a3 q, t# ?  P" i

int DestroyStack(Stack &S)6 h0 T# \8 f  Z! q0 L' i: i
{3 |2 J0 S. t- I# d) A: {
free(S.base);
return 0;  p% H; ]- w; ^7 f
}

int ClearStack(Stack &S)
{
S.top=S.base;
return 0;- `/ ^9 U: c7 _2 x/ i
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)
{% a: x# t7 q  k* e& Y# M( K
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);1 q0 r1 {) A5 H0 l
return 0;
}" }& u  F; _1 A) R& G, f1 c

int Push(Stack &S,SNode e)
{: q+ p5 p' A1 G* W* W& J
if(S.top-S.base>=S.size)( h! W! R7 Z9 p
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }5 G# f; g7 a0 R/ g  Z8 Z3 \
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;( \$ t. v$ S5 m" u& B
}
*S.top=e;
S.top++;
return 0;
}

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{- o2 V  y+ m2 U$ G3 s3 t  X1 l
      printf("栈为空!");
      return -1;2 `. x6 j' T4 Z) p2 l
}5 j/ }/ T6 f& ]' A1 H+ ]6 A- T
e=*(S.top-1);, A: I3 d$ b* r. R/ l; `
S.top--;
return 0;  l/ A) B0 j9 W
}

char get_precede(char s,char c)3 l! l5 P- S6 w) g1 `# k
{9 o3 K$ r% w: o5 H3 e+ B5 l8 p) R
switch(s)% R7 B0 b; e& j" q
{( e1 v' d" o: ^5 x1 A% y. z2 m1 e
      case '+':                2 o- d" I$ q' J2 P) E
      case '-':6 ]9 b1 E0 f6 s# e* ]- r
         if(c=='+'||c=='-')& L. E& b1 V8 r' Q8 C% N
               return '>';3 s9 ]4 A3 \1 P, f4 q3 K3 K- n
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')$ M5 z7 ?6 q7 w* u7 k
               return '<';  |: v( B9 P$ y; t) D4 F: `
         else if(c==')')6 s4 [; o, A* w6 l# A2 k* p
               return '>';9 k' I7 ~0 e/ D8 u
         else # U- G2 v. C. R" ?  |2 k* v
               return '>';! |$ S2 \7 P; Z6 d1 n7 i1 ?
      case '*':" k& v2 s& y* Y, [2 `: C
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';0 u9 t- m. K( b, p- O- P% z( p
         else if(c=='(')
               return '<';
         else if(c==')'); I) o' j* @; `! ]
               return '>';: n2 i9 j/ s/ P$ ]0 }) W: }- z
         else
               return '>';
      case '(':
         if(c=='+'||c=='-'): ~# x1 `' v7 k( l
               return '<';4 U! }3 r3 W5 r0 O2 T4 E* _
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')- i/ e+ Q# f: D6 s* B- s
               return '<';0 e. g; U2 g, d( Z: P" L
         else if(c==')')8 v, t3 K! v9 z+ [
               return '=';9 c7 l2 i" e. y2 l/ z1 P
         else
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')# |3 r8 `7 d% w9 i7 i+ i- R- N5 k) @
               return '>';! w+ a% n# j* P/ {& i$ _( v) H
         else if(c=='(')
               return 'E';
         else if(c==')')
               return '>';9 x; R: [, Z0 V% q7 b
         else& M7 {' f3 _& V  j4 J0 g1 I
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';3 F2 Q+ v8 A2 D0 b
         else if(c=='*'||c=='/')0 p1 d' T! o, n
               return '<';- k6 v$ r% L: r  A: m4 Q1 q$ \
         else if(c=='(')$ E2 f0 M. T) E- p
               return '<';
         else if(c==')')5 T) \- p6 i* S' x
               return 'E';
         else
               return '=';
      default:
         break;
}3 [" [, b  q  g7 P4 N/ g; N& V
return 0;
}

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;
}
$ r+ b, I; |; O- O* I9 P) I
float operate(float x, char opr, float y)2 h& C3 H; W. ]7 a& u
{
float result;: k/ C' G9 @$ Q/ |/ t( _
switch (opr)- I2 c) T. s# p4 a5 r) g2 @- ?
{: ~1 J+ w2 ^! V6 A7 U
      case '+':
         result = x + y;, g) [5 C0 p/ I- G
         break;/ B) k7 W/ V) ?: G+ F0 z$ \# l& J
      case '-':
         result = x - y;
         break;) g/ p) y( ?* G1 e/ i
      case '*':
         result = x * y;1 n. @) H" X; ~$ e1 c
         break;
      case '/': 9 c. {% [1 V3 b% l  y
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;
         }
         else& O% O3 Q1 B* F/ ~- s- R
         {
               result = x / y;9 G! E5 J$ H6 u9 p& @! S
               break;
         }2 D8 a- `& `: }$ F) @4 V
   default:
         printf("Bad Input.\n"); 8 c, u& C) }: J2 K
         return 0;
}
return result;% R/ m  k1 j9 a
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/: R: Y) z1 B* x
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;8 l6 @. C2 d7 z2 o  H
char c;
char buf[16];
int i=0;" A7 }! X2 b* q

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/3 s$ k, ]$ m( m4 z( X4 \6 F' Q0 V
memset(buf,0,sizeof(buf));: D: d4 W: \2 E' C/ X) k8 Y

printf("Enter your expression:");% ^  b, h- {: w* F4 t
      ; D) H7 H* i8 p3 D+ R) ^
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/$ t  s5 Y& L  t9 O  x9 B( k
GetTop(optr,opr_top);! Z! i3 e, p# o& J
c=getchar();2 n8 ?" Z+ b6 |/ b9 B2 D
while(c!='='||opr_top.ch!='#')3 q& E3 f9 P1 x
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {# k  w1 o& P0 o3 s: [
         buf=c;( F  a% z2 |1 D) ?
         i++;
% y- _+ V" v6 I          c=getchar();
/ b3 L9 S1 U* C* l7 [       }5 s! ~, U! r; E$ J
      else /*是运算符*/" I9 T/ ^5 X0 D. y
      {
6 Q, i0 A7 t& N! G. P% v$ z' N          buf='\0';9 ~  {2 |0 T$ y6 V4 q
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/; Q* x/ W- E. K
         {
( D: i: h- P4 ^9 D5 p" m7 h                opn_in.data=(float)atof(buf);  w+ k( z* v& V) k* \! r
               Push(opnd,opn_in);
, F/ w+ R7 Z- q; p9 z, n                printf("opnd入栈:[%f]\n",opn_in.data);. W% W, O) T: E- Z9 P5 {6 k6 F
               i=0;
: d( s# i1 X; N% ^. T                memset(buf,0,sizeof(buf));6 y0 D+ r8 p' ^4 m
         }
) x0 P+ f8 }" w( t          opr_in.ch=c;: k7 U! j! p; y! c& @& e
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
1 W1 [9 E. P" o* h          {
3 A7 k# R) K4 E$ N4 ]5 j# X# Z             case '<': /*优先级小于栈顶结点,则运算符入栈*/
9 m: T* A8 k  h3 U9 z                   Push(optr,opr_in);
7 O/ p. U) }) j' N* a8 A, r                   printf("optr入栈:[%c]\n",opr_in.ch);8 D- O' m/ s% b
                  c=getchar();
0 ]6 o+ b6 o; V# q1 [  u                   break;
. Z) E2 z% E5 w; P, ~             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/# ^$ B4 t$ q# E' o. u
                  Pop(optr,e);/ ^, Y6 S# P: N1 @2 e8 F
                  printf("optr出栈:去掉括号\n");
+ {8 [- B  _( B7 g! Z                   c=getchar();
' E# G. v8 G3 O* A5 L( c, _+ |                   break;
- e6 W  T9 Q9 \9 f# S9 f) n             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/# j+ D( o: k% h" E# e
                  Pop(optr,opr_t);
) H  O: B- S* D2 a7 j% F5 ?                   printf("optr出栈:[%c]\n",opr_t.ch);  e6 a+ e* ?  o3 F, N3 V
                  if(Pop(opnd,b)<0)
# [9 b/ t. S. l8 x% p                   {; C) c, r1 o3 {, |4 d  Y
                     printf("Bad Input!\n");9 k  O4 l6 Y- E( U
                     fflush(stdin);
6 V4 ]0 t% Q% d# l                      return -1;$ i: M. n0 D9 y) N
                  }
! [: y0 N: l) {4 @$ R                   printf("opnd出栈:[%f]\n",b.data);. G4 d; x" K3 g; L
                  if(Pop(opnd,a)<0)
  L1 e/ ]7 |+ X$ t* H5 V                   {
. B9 X" `. `% K/ o& r7 F                      printf("Bad Input!\n");; d1 d2 c2 b) H6 R
                     fflush(stdin);
* G/ e! h$ U  v, {3 D9 i                      return -1;
* Y/ V& `! c( k! Z                   }
# O# K" e" @. [" l6 D3 P                   printf("opnd出栈:[%f]\n",a.data);1 k; u' K- D  W0 I0 j* d' S7 I
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/* B5 n9 G7 `  x- Q' T$ y
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/6 y, ~* _* p2 n: s( B$ w
                  printf("结果入栈:[%f]\n",opn_tmp.data);
' R1 B! I* t0 C, K  f                   break;
9 B1 ?7 v( [+ t4 N/ J6 Q, i) o          }$ H2 ~0 U# g+ B6 W
      }
* s, h) F5 O' T( U6 M; ?+ N- g" @       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             $ V9 z8 f) z& S5 ^+ z' F# F4 T
}
/ d) X# g1 l3 O  C* } GetTop(opnd,opn_tmp);
7 }, }8 _' F. T- i5 t6 ~, d DestroyStack(optr);' M* E! v1 h9 R- D# W2 Q8 n4 k
DestroyStack(opnd);+ O5 n+ q# X' s$ D
return opn_tmp.data;1 {  e* z8 T. a) V$ W! M: u
}; R$ B2 a( M  H
" w- j0 @% ~0 Y8 x# v
char *killzero(char *res,float result)( Z8 I2 s: y" g4 p5 e
{
" s/ h- ]" _) C int i;
9 q" e8 M: u- M7 @7 X& {" K, ~- @9 ~: ~
3 v1 t; `) [2 \9 f' S! X" c3 n& L1 J5 ` sprintf(res,"%f",result);1 h! r+ K8 k* ~& B* g2 ]3 k6 A# T
i=(int)strlen(res)-1;! s! p# u/ @' p4 r. V- L6 ~$ T
while(i&&res=='0')
4 C/ a/ D+ z# Y {# h. v4 ]( ]3 D7 w( \( B! l$ `
      res='\0';
' H8 D! ^  _$ J$ y. R1 U8 U$ H       i--;0 N4 J- N- a7 f) t% b) Y" N  F
}. A" S! W) J$ R  }0 C
if(res=='.')
, }: @7 I5 c" h& a1 W  r       res='\0';" B4 L. g" f! y) k# d% s- C
return res;% o3 R2 c* D. m! t8 [. x4 |9 ?
}
( d5 i3 E" }3 J& I9 _& s& E' [1 f/ v' y% ?( [
int main()( _4 m, j2 G' ~6 g0 h( U
{8 e, R- O  u; L+ l: c5 Q
char ch;% C9 J, X- N+ ?) }
char res[64];0 B) b' w' t4 Q6 ?
float result;
3 k# ~" b, ?. K while(1)
" f! g# h$ i( J" p {8 ?9 ^; v# L2 |! X& Z8 D9 M( v8 J
      result=compute();& q9 v) ?4 I  {$ `7 U; E
      printf("\nThe result is:%s\n",killzero(res,result));% G3 R+ r% j1 {2 ~' C) V
      printf("Do you want to continue(y/n)?:") ;
& F' J/ _8 D+ B/ P7 }6 R: t       ch=getch();
! i, i6 H! `8 Z% i7 C       putchar(ch);
% b8 P# C) h7 q2 d% ?4 m: S       if(ch=='n'||ch=='N')2 V5 y- m/ z2 X8 K
         break;- T0 Y1 w0 Z  K7 d3 I
      else
, G' ^0 C1 k/ Z0 G: X3 Y          system("cls");
2 l% p* ]5 R% x) p }3 T% ~  Q! `, P2 Z1 [' c1 o$ c) o) G7 ~
return 0;
( g. t! c2 E! o0 R9 L0 {. e}' M8 q6 J: U% ~3 X) T
1 d7 O! E( g  l. p8 Q% {$ \  F
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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