捌玖网络工作室 - Powered by Discuz! Board

标题: C语言表达式计算器 [打印本页]

作者: zw2004 时间: 2008-1-21 17:17 标题: C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=5 ?$ U5 d, w' H- [( r
/**************表达式计算器************/
#include <stdio.h>5 J. z/ F% s3 y/ w9 J9 L5 |
#include <stdlib.h>
#include <string.h>
#include <conio.h>- L/ b: g: J; C! h0 c  `9 U! ~4 D  O# G5 A
#include <malloc.h>, Q8 g. i5 O! N4 M6 D
: m- a. m- B0 W: q: _! L2 \
#define STACK_SIZE 100& F0 O  a- ~: Q: k  W  \6 `
#define APPEND_SIZE 10

struct SNode{1 |5 X' ?* S9 v- r0 M# Y/ `" H# ^
float data; /*存放操作数或者计算结果*/7 Q' c$ W5 q' U4 ?* O, P- j* x+ w/ [
char ch; /*存放运算符*// p, Z: f+ H( P$ x" M
};2 e5 j2 ?7 V# ^. m: k
+ p; I) d& b9 H% m. x6 A$ T
struct Stack{
SNode *top;0 _4 j6 X" ^/ O) ?
SNode *base;
int size;
};9 k/ O; K8 ^$ ^
. b  {, j5 k8 j& Y2 Q
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/: K8 ^- v) }  l) J# h0 W
int ClearStack(Stack &S); /*清空栈*/) A1 O- ^# [5 }( }( I# h" V* @' _8 T
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/7 s8 Y* A! q0 O2 W& R: ?. v6 w) [
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/. D1 r# |3 w" v! F+ j
6 x4 c( m* f+ W+ _4 E2 d. n
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/+ D9 M; T2 j1 W9 k/ x, O$ a2 o
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/7 u4 t* j, f- e2 H' S
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 6 p2 K! P) A  Z# Q6 q
) e8 _! N6 I2 ?8 R, N! Q
int InitStack(Stack &S)0 g. E" d. r, @& @
{+ R8 l6 [/ Y4 Z, A2 _
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));+ w8 g% N2 ?" W% _1 F1 S7 |
if(S.base==NULL)
{: z' H2 t) Y! a' q* L; d/ ~: o
      printf("动态分配内存失败!");
      return -1;- w+ X' `: k7 s- C+ f
}
S.top=S.base;* S* c0 b$ C& w4 a
S.size=STACK_SIZE;
return 0;
}

int DestroyStack(Stack &S)
{: q4 w: P8 `4 a% F( q
free(S.base);
return 0;
}
1 x! `$ K+ n3 P, p
int ClearStack(Stack &S)' o6 C7 _$ @( ~* X- F
{; h# W7 j! @) p) S3 P3 c5 A' z
S.top=S.base;
return 0;
}
; X9 r+ B, s( J3 @- V5 z$ ?
int GetTop(Stack S,SNode &e)$ d4 P& T7 ~0 m, v- H) {/ A
{" ]0 D8 |9 t% G- J
if(S.top==S.base)
{
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);
return 0;' i% R/ [7 N, S6 ^/ ?
}

int Push(Stack &S,SNode e)$ k9 y# C1 O% {9 C  ~
{
if(S.top-S.base>=S.size)8 ?  \6 t9 D- a% R
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;3 A: @! X8 ^: }9 B& k
      }
      S.top=S.base+S.size;+ m6 V5 n* @! r3 k+ [" z
      S.size+=APPEND_SIZE;
}+ l( g/ H# |& x1 I2 H
*S.top=e;5 z8 b& r/ E5 ]3 s7 i0 e4 Y
S.top++;
return 0;
}
  U, w" Y# d' |( \6 `+ E7 H" _
int Pop(Stack &S,SNode &e)
{8 T8 Y0 b6 [% w
if(S.top==S.base)
{1 a' v3 L" B! ]" w" ]  a* k
      printf("栈为空!");! P: g# l+ P! U* |- @* C
      return -1;2 M! r) `1 b# \3 A* b
}
e=*(S.top-1);
S.top--;
return 0;  n! M( W5 m) I' X0 e
}6 B( c+ i  w4 g& u1 }

char get_precede(char s,char c)' c7 \- O- N$ Y$ m9 M' z$ f
{
switch(s)
{5 @4 y* G2 Q9 o$ s4 Y
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';, O) ]) E1 Q9 n0 Z( v+ t# F
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';2 e6 ?9 @" f1 ?1 P; ~$ R2 O" }
         else if(c==')')3 C. y+ W/ s$ M0 I
               return '>';
         else / k: m. r! f& w$ `2 s
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';+ I8 s( e) {8 O% ?
         else if(c=='*'||c=='/')3 S% `! e; d: d2 j
               return '>';( L: ~# u7 K2 [* D# t
         else if(c=='(')7 c1 D0 N' w+ B; i" W
               return '<';
         else if(c==')')# N% M+ q8 [& b* b2 G" ^+ k
               return '>';! ]0 i+ v& ^! H; h6 q3 m$ X* G* j
         else/ }5 O8 x0 d) O
               return '>';
      case '(':* N( r$ Q+ N2 J9 F& {' U) v
         if(c=='+'||c=='-')
               return '<';/ J( [( P8 m$ A) d" r- l
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='('). H; M. C2 h) Q) m4 q( U$ ^, F
               return '<';. f# a! J( b4 t$ a' s+ u
         else if(c==')')
               return '=';5 C$ u% G* _: |
         else9 s* E- T4 L1 `! F' x9 n1 {
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')) h$ U- F) ?( S' k: _$ E
               return '>';
         else if(c=='(')
               return 'E';0 U. c4 U+ w6 P
         else if(c==')')
               return '>';
         else+ }( S* ~8 T* J, P7 D
               return '>';
      case '#':
         if(c=='+'||c=='-'): x8 R" A9 v- E
               return '<';
         else if(c=='*'||c=='/')6 A1 C. p  |. f. ^  [9 @1 x
               return '<';5 p3 D! C8 g- f5 ?" J* ]
         else if(c=='(')
               return '<';) r1 T8 ]5 \) I& X' C( M. f
         else if(c==')')# t' ?0 Q. N! d* n9 i( Y
               return 'E';
         else
               return '=';
      default:
         break;0 J. q( p. Q# ~) o7 P
}) e1 k" {: e. E- m! n) M
return 0;
}
7 d$ F. z3 D3 k: s
int isOpr(char c)
{+ H1 |/ V6 @7 [
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')# W& P( r0 K+ S; e. x, }( L
      return 0;
else 2 h8 c+ j0 n% v2 S  e% \' M" P/ I
      return 1;+ i. s  W3 [% x7 ]  F3 F
}
  }) W5 J7 h$ m. X2 v/ B" w
float operate(float x, char opr, float y)
{) n, G5 V$ X% a' F
float result;# H6 D) J/ H$ x3 G: M% {% Q; Z
switch (opr)1 \. B) p, x" e0 Y  X6 V
{
      case '+':
         result = x + y;
         break;. f! I% e$ L- m
      case '-': - W7 _. W2 x2 r8 h, ^% h" a! _
         result = x - y;
         break;7 e- N1 j9 [/ T+ s' y$ N) F
      case '*': 3 b+ ?: ~9 E! i% ?% ]; _6 c2 n
         result = x * y;$ h4 D) v4 X8 f" ~
         break;
      case '/': " [+ D) V; q* ^4 s6 n; W
         if (y == 0)9 d8 c/ d- x8 U: l3 W% x; a4 Q
         {# B9 S. f9 V  T; f2 C/ {  R
            printf("Divided by zero!\n");) A+ C# C, h( X# w# z& T
            return 0;
         }
         else$ ^3 H; m3 q# C  ~+ J8 a/ t# P
         {) W, k3 p8 u, ]+ M+ U6 d- s
               result = x / y;
               break;
         }
   default:
         printf("Bad Input.\n");
         return 0;* k) v! v( {) i$ I1 x
}% i4 m! g% N- [/ ~/ T
return result;2 y4 R0 v1 N3 C' t5 a. f6 R
} $ t6 n3 K, `3 d1 A

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;& ~) p5 [# b. H% ]& C; D+ H
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;1 l& x$ f1 p; [6 S
char c;1 o6 T1 H! @6 p: M
char buf[16];
int i=0;
/ l* m. Z. l0 e& ^( u. |
InitStack(optr); /*用于寄存运算符*/! d5 N( r+ B6 s+ B3 F; z
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");, B; X" D% T9 I" [4 a$ m

opr_in.ch='#';2 v  u7 L: T: Z9 w5 t, I% ~
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();" d' e2 W5 i& W
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
* U4 }  P; R  I% Y7 L, X          i++;
2 h4 ?$ W6 {& K1 f4 d          c=getchar();, |* p0 |( @" \
      }
& U+ s& W! @  J3 u8 X       else /*是运算符*/
) i, ]% R4 T4 B: D; b       {
" f5 I9 o5 @; K( p0 e8 \          buf='\0';& F7 Q/ E3 `* ?' Y4 h4 _' e. e% X
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/: w+ q4 ?4 h* `$ R' Q) A5 q
         {
8 N5 b& L6 W1 W                opn_in.data=(float)atof(buf);
4 _5 W  v0 G8 X5 ]% C                Push(opnd,opn_in);9 s% d1 O6 k7 C, R
               printf("opnd入栈:[%f]\n",opn_in.data);( ^' f  F; C# Q; Z: I3 f7 `
               i=0;/ s: S2 |- E& `+ N2 i9 V* C7 L  ^
               memset(buf,0,sizeof(buf));
4 q' b4 z6 K+ e% r  O          }
" |; Y* M& i5 C  ]! u6 a          opr_in.ch=c;
8 ?: B8 W' b( Y4 P2 l          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
: `; c# w* c% b% b  B$ n          {4 t% X- [0 l* F7 E& w
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
& t+ Y7 u- D  C4 D                   Push(optr,opr_in);
: X% v' j: \2 G1 h3 H0 v                   printf("optr入栈:[%c]\n",opr_in.ch);& F  I1 ?& V# P" b
                  c=getchar();
  N) T# ^9 T* ?6 l                   break;
/ u- d7 e3 r& O5 A& r; |             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/. v- f' F, N) z3 t7 b% n0 M
                  Pop(optr,e);
8 e! J" j* N, v7 e( S                   printf("optr出栈:去掉括号\n");
- s: B# _: w; \2 G+ p                   c=getchar();7 m. _$ I6 [2 H8 L) \8 m6 Y. C
                  break;  V6 T$ D0 I8 ~7 Q3 v# k" X, G
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/5 e, h) v: r. L' X7 |
                  Pop(optr,opr_t);
" W, q+ e' ~  Y& y$ N; H                   printf("optr出栈:[%c]\n",opr_t.ch);
6 \8 A. l6 n; t1 @; W- P                   if(Pop(opnd,b)<0)9 z* m+ m% W1 y9 V* u" r4 H- o
                  {
$ V6 m$ ~. Q0 n$ B0 b, r                      printf("Bad Input!\n");& `& @; S3 s9 }
                     fflush(stdin);5 X7 p' u+ x# D! b) R9 ?5 X& A
                     return -1;, @- X/ ~6 W9 H1 P
                  }* R" j1 q, }9 J; B  _
                  printf("opnd出栈:[%f]\n",b.data);! e( d8 {" i6 W- ]+ p7 p
                  if(Pop(opnd,a)<0)
% @$ s5 b% c+ k                   {$ c. }1 U9 E( p2 L" F' |
                     printf("Bad Input!\n");5 C# A, i  e$ M. j
                     fflush(stdin);
/ E' `2 n" y! b( x  q* R                      return -1;
9 a; {& m/ ^6 P5 G+ Y4 Y                   }
! U7 a8 V" E) h& _2 v                   printf("opnd出栈:[%f]\n",a.data);
7 W" _7 P( v3 d! ]7 \/ S8 p                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/. ~; M/ b# z2 h, H4 f( }9 A
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/1 C" E8 @7 b; ~& M! M
                  printf("结果入栈:[%f]\n",opn_tmp.data);
- o$ Z$ ~6 S* E7 ?% i7 G                   break;0 h3 C; b2 x# y
         }
/ e  l9 t( h$ M       }! D$ d! f$ a9 z; o" I0 `4 _
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ( W7 _* K5 |7 i  ]- \6 \- l+ c. s" \
}6 v( a$ w9 B) a& T2 G8 s1 l
GetTop(opnd,opn_tmp);
( Z+ Q1 z) n  w DestroyStack(optr);
, S5 k7 ~; H9 s# \1 ?. v* l; z DestroyStack(opnd);
/ q6 `8 ~( B# |/ F% c" v9 n return opn_tmp.data;! |1 q) ?+ r2 x, q
}2 b) s% S, e/ p- s8 S  M7 b1 m* O
' K& m  s' V& b2 F
char *killzero(char *res,float result)
  e! A5 P4 b5 p, I. R2 i{: n  d/ C! F# w- u" z
int i;
: r7 T8 V# W2 j7 f
% {% K" R6 u4 d/ k/ t+ J& }& Q, Z sprintf(res,"%f",result);
- a  ]7 h6 _* u) F* j8 m* A) u i=(int)strlen(res)-1;3 ]4 f& I1 C0 _; i2 H: M4 H
while(i&&res=='0')
+ ^) ~4 ?, ^: L' J {7 E: D5 d7 ~0 `5 j
      res='\0';* c8 b) C: `; d2 |4 o
      i--;; {- m( V+ G7 }' [+ ]: m# d
}4 N: |( Y$ x0 {' x: q
if(res=='.')3 _7 ]# }* t! G6 u
      res='\0';
  y4 C1 k, Q/ ` return res;# L, a0 x4 h* `/ y# J, {
}+ v; j. W; d& N/ \6 }/ S' D

7 k  c2 ?- E6 N6 b4 {int main()
! u9 {1 K' W# g' W7 k9 b8 A9 a{7 S5 L: @; t9 Z+ C' e$ h6 k
char ch;
; _* B6 `& u" w- ?; u: Q# e char res[64];$ P5 G" T2 i' D. N8 t) t: Z6 U) s
float result;/ ]/ N6 j7 J; G! v2 e" [0 _" C
while(1)
0 V: v" |" o8 j+ Q, o% z& K {
8 q, z- O0 {2 W4 \" g$ a$ d       result=compute();
1 _6 Y& E  \; ]) f: F* L, k+ e0 H7 O       printf("\nThe result is:%s\n",killzero(res,result));8 L' B( X8 _) V' j$ c* _+ v
      printf("Do you want to continue(y/n)?:") ;* e6 q* l1 A( y$ M# v0 o, V) u1 ~! l
      ch=getch();  V, D4 D, z; k) w5 B. c- I
      putchar(ch);/ x2 b7 P$ C2 L' |3 m* [
      if(ch=='n'||ch=='N')
; \0 I5 [6 Z' s+ b( W          break;7 z1 B; ^* j: [
      else8 o4 _( x; g6 D9 A5 U0 P! v, M
         system("cls");
5 W$ n8 ~# s) K/ U1 w; }0 u }
' n" ~* B. U! H4 {" O return 0;
% |4 z9 Q- k9 p* V2 K- g9 _, B}2 ^9 v( Y$ G* n' M* O9 P* I0 `
/ B5 y# R8 O4 h# J
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

欢迎光临捌玖网络工作室 (http://89w.org/)