C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.! ~' q8 r9 H0 r' S% d8 x) z
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=% d$ K! a: s' C& h& p+ {
/**************表达式计算器************/
#include <stdio.h>/ M8 X* d, {0 V. i
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>( D7 h- N0 Q+ J7 w+ I, Q  |8 W$ S

#define STACK_SIZE 100
#define APPEND_SIZE 10
0 c' k0 ~5 L; z. b, P  Z
struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};

struct Stack{% g4 B4 m- n) O5 X9 `1 [1 \
SNode *top;
SNode *base;
int size;
};
: [' m3 }/ R, R. w9 X0 E' a
/*栈操作函数*/9 i$ J% Y: t; v1 s# y1 R. C
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/3 [- _& F: _4 d, H0 z8 ^6 W
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/4 ?  }" Z% f! E2 K, B* e6 y
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/1 E/ H7 _2 z& d7 J& g
* }' R8 F% y/ l, N* f5 b' J
/*表达式计算器相关函数*// c6 n( l' R8 O5 x
char get_precede(char s,char c); /*判断运算符s和c的优先级*/  I! X- J# K: N, U4 w; o
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/7 L  P0 z  l! J/ J5 u
float compute(); /*表达式结算器主函数*/; V, P$ |- [; C7 C3 s
char *killzero(float result); /*去掉结果后面的0*/
$ @, k( H% l7 E% ^- U3 U7 u
int InitStack(Stack &S)
{+ V; Y  ?' n( A" Q
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));% d4 ?1 ]1 o* v+ C
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;; d* K3 M/ Z6 A" H6 d
return 0;: d3 W" U- {; Y9 a+ m& P4 t
}2 z1 G0 T  Z3 g2 G6 T. t& P# b
7 x( `2 }' e: g7 X& m
int DestroyStack(Stack &S)
{
free(S.base);
return 0;
}

int ClearStack(Stack &S)
{
S.top=S.base;. C& ?7 X/ `, ]) l# D: m
return 0;6 S. N% U( P( J2 r8 D" C& t
}

int GetTop(Stack S,SNode &e)
{$ F" ~- m) t3 r" n& _9 a
if(S.top==S.base)
{8 B( d, S1 X, Y' ]; }% v
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);# }, ^. ]9 z9 C9 g  U9 P
return 0;
}

int Push(Stack &S,SNode e)2 d$ e. i2 {1 v4 a* V4 x# m
{% ]+ K( V# ?; F/ ]
if(S.top-S.base>=S.size)
{' e4 S2 B; }# R. [$ }8 P/ h! B
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)" w0 w7 }, a7 b/ h  \
      {: W" n1 r3 W( W
         printf("动态分配内存失败!");7 l& }" u" L' [
         return -1;
      }+ L  A% ?) ?" ]8 n
      S.top=S.base+S.size;: B& A+ B- K+ f7 \3 O: B5 c
      S.size+=APPEND_SIZE;
}
*S.top=e;5 `- m* u# C; Z. a; g
S.top++;
return 0;
}2 ]9 p- U6 y* i+ K4 Q& W% z7 o4 b
/ S) H& ]- S! }2 _, c9 Q
int Pop(Stack &S,SNode &e)( O- r+ R" X! k" s
{' ~, }$ }& R( e8 R, B) V5 I
if(S.top==S.base)" X& o' J3 t( ^9 l# V
{9 T6 v- I' b8 V, Y( A% _5 {
      printf("栈为空!");, y% {9 o! h8 C6 O" n) y$ p
      return -1;& g5 M' f: Q6 e# T! @: E
}3 \! Y9 G# c: Q% h+ S4 }
e=*(S.top-1);
S.top--;2 M1 j* y, D9 @% L: B* m  l+ k$ q
return 0;9 C' N& p% Q2 ^
}2 F$ M1 l/ [5 g
0 W; x1 n# M" c' q4 L
char get_precede(char s,char c)* [! u, n; ]4 [+ n) ]
{+ ~3 M" w( W7 p0 C/ r
switch(s)
{: L9 J6 Z6 r+ K  X% W0 {$ ^) B% o
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';1 J1 z5 K' i* E2 S, O! R
         else if(c=='*'||c=='/')( W$ j" _' |1 D5 D6 D/ D. Y
               return '<';
         else if(c=='(')2 s$ ~" X9 Z9 s) e) F3 c2 }2 u
               return '<';5 \' i4 U, |& p+ G
         else if(c==')')
               return '>';. ~' O9 T1 v3 e
         else & G, o3 A: V- d4 k# ?$ s
               return '>';+ ?% ^1 X) c: H
      case '*':1 @/ @/ Y& @# b! v! w
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')+ e5 L, v# X5 P
               return '>';. t# M, H8 B. O6 e  Y
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';$ R8 n! Q* D; O: U' G7 }: W! X
         else" u3 k  e! M( J( A7 f
               return '>';
      case '(':4 C# {; @4 D( F0 _+ G) ]: L
         if(c=='+'||c=='-')
               return '<';( M; |" r8 K5 x7 [9 t
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')5 G; d; y/ u1 ~, V$ c# |
               return '=';$ ?1 X8 C. P  O$ V% c4 w
         else$ a# H) Z, P- W3 d/ Q' J
               return 'E';$ @9 T7 i$ F% @6 r/ Z. h0 @
      case ')':
         if(c=='+'||c=='-')
               return '>';7 j$ Z3 T) y9 l0 E  g
         else if(c=='*'||c=='/')/ n3 ?5 j% G, T7 y
               return '>';
         else if(c=='(')( N: |# c0 {, q9 o; j
               return 'E';
         else if(c==')')0 e% ~3 O0 }9 N* V4 e# w
               return '>';3 D( F" B* b9 v8 h7 d" d
         else2 ^, I) g; Z8 W5 y# `$ F+ b
               return '>';1 D% E; t; `) y% C
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/'), V' i& Z+ Q9 T- w6 Z
               return '<';6 B  i$ |7 L& B' f9 g  S- ?4 s
         else if(c=='(')
               return '<';& w1 y. k3 E$ K/ |6 {) j+ K
         else if(c==')')
               return 'E';0 V1 H: g  D, C# Z
         else+ \* r) A  p5 P7 L
               return '=';, e. R3 L7 v2 u, N0 Q# S
      default:
         break;
}
return 0; " @# b1 k% L8 U+ W5 r2 P3 o; O- b
}3 O; E0 X# d" ]! v+ m+ w& R; D' W+ H

int isOpr(char c); T6 a9 e  X4 e8 f
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')7 w( }+ x2 R) {8 |6 ?* q
      return 0;
else
      return 1;4 I6 k7 v( G: c1 ]+ z
}
' Z% g2 ]6 j2 X* Y* M
float operate(float x, char opr, float y)7 h8 ^& U# A* P
{* r: g9 C; n! [
float result;
switch (opr)3 {- v! I9 @. Q* u/ B1 `( y
{
      case '+': , V5 ^: `0 T. h3 |& H& w& M9 M5 m& f# F
         result = x + y;
         break;+ P. M2 s: y3 a9 C  I
      case '-': ( B# k8 ]* g0 k$ [8 U- Y
         result = x - y;
         break;
      case '*': 7 Z9 ?( M+ N, R5 e
         result = x * y;
         break;9 [8 Q& V( I7 X4 y0 s# F& w5 J8 W
      case '/':
         if (y == 0)* @9 M4 X" w1 B' ?" E
         {. T0 C! r" V5 v
            printf("Divided by zero!\n");
            return 0;8 E$ D0 M$ ?9 W1 R# F* s# \" J
         }( p: V' b* k, k
         else
         {
               result = x / y;, K- l/ H. ^1 @- |. e
               break;
         }) S* {( n( U9 Z# a% B
   default:
         printf("Bad Input.\n");
         return 0;" x5 @* ], J3 k1 E* p) ~8 u5 h
}
return result;
} 5 r& k2 _& Z( [# F

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/. ?/ A' j* M/ G3 T! o/ H
{  @6 l9 h4 f! H) G; i
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;& V5 v/ L' p- X* ~( R0 D9 p8 s
char c;6 }0 b( I, @* F7 A" Y7 [
char buf[16];5 |2 l4 |# L9 s& w
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/+ i4 [& o# _, ^$ e
memset(buf,0,sizeof(buf));3 d$ E: D! v1 y4 U6 Y5 X0 [$ T

printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();% n5 @) y2 ^# N% q- Q) J
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
# k0 j# A9 B3 y! ?) g" A# U          i++;
6 g& F- m  r8 E          c=getchar();: i# j* Y# r! M. h, Z
      }
2 {+ `0 U0 f2 [8 X+ }4 s       else /*是运算符*/5 Z' N' l; ~. @! U
      {& O4 e( V0 R% E" A, y
         buf='\0';; N1 ?8 f5 `: j3 l- n! B
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/4 b( _1 W8 a7 A/ h0 m( ~
         {
( |9 n: f6 E& H* Q                opn_in.data=(float)atof(buf);8 b# M) V% g' ~" @& V
               Push(opnd,opn_in);; G. m+ v+ q/ k* k8 l9 V' ]- S
               printf("opnd入栈:[%f]\n",opn_in.data);
( [  S9 Z$ _3 C6 I! ?                i=0;( f" E3 S& `' `; ^
               memset(buf,0,sizeof(buf));8 g/ v- ?5 F* `7 ~- h
         }
$ R. `. W! i# B& Q* o          opr_in.ch=c;) T7 Q. Y: t4 m/ \* q, s1 H+ _0 |. s' k
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
8 R1 \' f/ v! Y& W          {9 B. ~$ l* o# Y$ V. S* ~& _; m
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
) z" n+ @4 w2 g9 j                   Push(optr,opr_in);; b% Y+ s' D, f" k* A
                  printf("optr入栈:[%c]\n",opr_in.ch);: S/ W7 T  r- v* W$ c3 W
                  c=getchar();- j" j. w) z; `6 W0 L
                  break;% ~% r( Y+ b& w8 P8 p: c7 \
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
1 H9 U% S$ n+ c. r; a" q                   Pop(optr,e);
9 P- u9 E9 H1 G6 `' q                   printf("optr出栈:去掉括号\n");7 k: W- N; c2 Q# B! e
                  c=getchar();
3 F( _9 e1 r4 t8 a( T0 E% _                   break;8 @& e& `* u7 l3 n8 [, R2 Q* z
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
+ v# o! E+ |9 v' |( z8 Y0 G3 b                   Pop(optr,opr_t);; i/ ~3 k7 V: t! @) q1 W
                  printf("optr出栈:[%c]\n",opr_t.ch);3 ~3 i) X- t! E# p( w+ T3 D; ~
                  if(Pop(opnd,b)<0)
% i# q( q+ K# I5 Q                   {6 g* h* l3 ~9 Q" Q/ P! s
                     printf("Bad Input!\n");
' ^. @, {. l2 H2 J                      fflush(stdin);' z& f+ X, U0 I0 N1 e3 l3 ?% L+ n
                     return -1;
. p) E6 u  o8 F4 X% I                   }
6 N8 k% f0 n$ Q- A- h                   printf("opnd出栈:[%f]\n",b.data);
* I8 _3 `2 ^1 W! b4 t                   if(Pop(opnd,a)<0)
+ E  U/ b0 `( m8 R3 e9 E                   {
% \) z3 @; d" \+ s: {; [5 k- ?                      printf("Bad Input!\n");
8 J  V5 E! E9 ]# s8 H- C                      fflush(stdin);
) E1 X6 x, Z/ B                      return -1;% i$ E  i7 e* z, |7 _" u  T+ A
                  }" S- `, C. Z1 W+ q2 |* |8 ^
                  printf("opnd出栈:[%f]\n",a.data);
+ W- N& f6 s1 v8 Y, j2 U" M- L: b                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
, T! j' v; m% P: Z                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
% T$ F( @9 |/ I; O# q                   printf("结果入栈:[%f]\n",opn_tmp.data);) [1 Z& J3 L6 U" S
                  break;
         }
/ R. Y2 p% Y- G. Z/ J( ~       }
* T8 Y- [6 s$ G$ m       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
5 I- z" R5 H7 c$ g8 x1 e$ E }
1 I+ w8 d6 M. m2 H GetTop(opnd,opn_tmp);7 C2 y- l% X5 Z8 ]
DestroyStack(optr);# g* `% h6 d6 Z2 H2 x' Z. M
DestroyStack(opnd);+ d7 k2 K; ~4 h: I/ r
return opn_tmp.data;
3 V$ E2 L% f' m$ o  S) ?+ q* ^}1 @+ \5 W/ N. |, j' D* x) k, D
% Z9 [4 W+ {2 ^/ I; a; \
char *killzero(char *res,float result)+ G- V: F+ V% K0 Z
{
7 p. O( V* p9 A int i;
$ F$ v% ?, _0 ]; Q3 n
" ~3 y* f& }+ m' N5 v1 U sprintf(res,"%f",result);  P) q- p' A8 L! F% Q* u' Z
i=(int)strlen(res)-1;
( l) P5 o- K  v while(i&&res=='0')
$ d, T7 f2 R! n3 L$ D {
1 \2 q# u# p0 v       res='\0';' @. [# g1 B9 n" G* h
      i--;6 H$ x3 |5 j2 C
}0 h; [8 ~/ ?$ c5 C' K- l
if(res=='.')+ q) |- W7 C8 R7 R
      res='\0';
! w6 B* V9 O8 E" A/ Z, |6 k return res;
& [: ?$ u; b, P) G0 J  A" p% |7 u}
6 \6 b7 }% T! C! D" |
, r( B: J* b" o* c: G5 Zint main()6 z5 H  D% ~! n. j& `# Q+ l* j/ V
{5 S0 x  l7 S$ N+ H
char ch;
% Z- h8 `" D3 l6 i/ O char res[64];4 }, d! \8 b2 R: ~$ o
float result;
. T& j+ b. ?+ } while(1)
6 n( p% a7 n5 L {
# c& c- V3 U+ A! H# D5 V       result=compute();! v, a  P5 ~, d2 i
      printf("\nThe result is:%s\n",killzero(res,result));
$ M* X5 v( j+ c6 q$ C  {       printf("Do you want to continue(y/n)?:") ;
/ K6 o( j( M: j' B& E% a  f       ch=getch();* t! ]* c; O$ n
      putchar(ch);
/ L3 J: z' o7 {; s9 r: j7 E       if(ch=='n'||ch=='N')( ~5 K( \  j( A. i7 W8 W5 Y; `
         break;
; r- Z8 }/ |* B- T$ ]       else
# Z1 q  j' S+ u# _          system("cls");4 N0 e  m0 ^0 B# Y' W6 @
}
1 |0 p$ Q- S9 [" s" q return 0;+ K! K; L9 q* `8 n, _
}; c$ J4 B) t+ m" v2 E* d6 j

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

返回列表

C语言表达式计算器

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

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