C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>0 z  u& E; Z( Y- L" |
#include <stdlib.h>
#include <string.h>
#include <conio.h>% H1 p) Q$ M: d9 ~& W4 J
#include <malloc.h>
: L% g7 K" u9 ^
#define STACK_SIZE 100+ I# f9 H+ s2 u, {
#define APPEND_SIZE 10# \8 O! Y% h$ U( M- x+ w" \' {6 {9 S

struct SNode{
float data; /*存放操作数或者计算结果*/) |1 L" l- K. I2 A+ {( |
char ch; /*存放运算符*/
};
0 x+ p( S; w6 e: B8 E/ z1 Z
struct Stack{5 X! {/ \6 s2 ?' A
SNode *top;
SNode *base;
int size;
};* |6 v- h9 c5 u' d$ S! Z5 v
( v! S8 t& @0 Y8 A
/*栈操作函数*/( c+ i8 k, A% u& }7 Q* U' P
int InitStack(Stack &S); /*创建栈*/$ _& |. o* ]& S8 l2 L9 W) j
int DestroyStack(Stack &S); /*销毁栈*/) L" G$ }4 N- D: S
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/* e$ \  L$ a) z& o8 X

/*表达式计算器相关函数*/, e- ]: ~. t* D% y. g  D+ L0 Z- D$ y
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/# G7 u& C$ ]# {& A8 {5 }" A2 m( V$ M
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/4 p# h! H' z1 {+ f) O
char *killzero(float result); /*去掉结果后面的0*/ 6 r- T$ K$ r3 L2 S3 c4 w" F
: c+ H+ x( G6 y
int InitStack(Stack &S)9 L; V  Q# y) n2 ]/ x0 A% A
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));# L- p* Z9 k* N. S8 j" x. h
if(S.base==NULL)/ E! F& o9 q/ f: w: I
{; E0 {6 a' \' e' H% f. G
      printf("动态分配内存失败!");3 F4 F: Z2 W: V. {7 s6 t! V
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;6 P$ A( s  [+ h# \: o' Q0 m
return 0;
}9 L" D! g: j' Z8 N
2 L) I, v" u/ Q
int DestroyStack(Stack &S)
{
free(S.base);7 e% h5 b$ X0 J8 s9 @
return 0;
}" e0 R7 }; f; |, z" @( Q5 x% ]# c
( b9 \1 z' L8 X' J9 X* b/ b
int ClearStack(Stack &S)5 y; H2 W9 _( E* U, u; f. @' F/ H
{
S.top=S.base;
return 0;! A2 Z+ e# |3 Q: P$ g
}
' Q0 P' k: E5 a
int GetTop(Stack S,SNode &e)2 n: ]7 u# o7 [# Y9 n
{
if(S.top==S.base)
{
      printf("栈以为空!");
      return -1;0 O- P" T/ @1 n& Q' p" f7 Y1 a
}
e=*(S.top-1);
return 0;
}0 e3 q+ R: }9 D6 ^
1 @$ O: |+ _& L! @& c+ F+ k
int Push(Stack &S,SNode e)) P: O+ [( Y8 z" ^$ E( z* R6 ?
{0 w) w# [8 g) _  g0 k1 i& L
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("动态分配内存失败!");; M- r. V1 _& o4 P! o: y: c
         return -1;
      }
      S.top=S.base+S.size;! |! Q; ?+ s3 y2 m5 u' X5 ?4 C; Y
      S.size+=APPEND_SIZE;
}
*S.top=e;
S.top++;
return 0;
}7 v/ o  q( I+ S4 x

int Pop(Stack &S,SNode &e)
{9 i' q( Y* F+ @1 B6 g, R
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;
}& W3 N: y) d9 d* c& Q
e=*(S.top-1);1 Z) S0 Z1 ?# `; h; B* s7 d7 s
S.top--;+ h9 e3 j& c: _
return 0;# L; f- a7 A7 y  O
}; p& D3 M! a+ Y/ G' g  ?! w3 A1 b

char get_precede(char s,char c)
{
switch(s)
{* B4 K. w. C! W0 q( c
      case '+':
      case '-':4 d$ k6 v: b/ a% B4 m
         if(c=='+'||c=='-')
               return '>';' c+ t& m7 D  p  T- N  w7 B
         else if(c=='*'||c=='/')2 v6 b5 @5 J; u2 b
               return '<';2 J! a  M& Z3 I. P, U
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else - H: B7 u; ?9 `- J' a7 V) V
               return '>';  R6 t* d) V4 {# T5 T$ S' N! }
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')& |4 E/ w6 m( v$ z2 M
               return '>';
         else if(c=='(')
               return '<';0 [- L+ f  p" T2 Z2 G0 h
         else if(c==')')
               return '>';5 V3 x' M* z0 O
         else9 D" j7 N3 F5 v3 g* H  L6 i
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')+ J% m  I* ~$ a; J9 R$ r  Q0 H  g5 W9 n
               return '<';- x$ t2 q4 z/ ]" U' V
         else if(c=='(')5 A1 s  F; l* b
               return '<';8 _) S. K% a5 w. k- j. }+ _: D
         else if(c==')')+ w( w+ [+ b1 }& c$ I
               return '=';2 J" o: k# z1 Q2 E- u: l- m$ p1 u$ P
         else
               return 'E';
      case ')':( K' J" Z0 T2 R5 s5 n- N6 Q# `/ G
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')1 S3 v. o$ s3 h" m/ B
               return '>';
         else if(c=='(')
               return 'E';
         else if(c==')')* }8 @4 ?# Z& ]/ M
               return '>';
         else
               return '>';( z7 ^" U! p* ?2 p/ a! b0 [
      case '#':/ D$ u9 J0 K4 {
         if(c=='+'||c=='-')& J/ b5 T6 c, y8 K( F
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')9 V! J, s" h* E! o- o: |- y
               return '<';$ o$ H) _1 E, Z! r  |; R
         else if(c==')')& z  `* O0 Q  B+ |, v2 f. y# P: g5 C
               return 'E';
         else
               return '=';) R8 A+ U' d5 J  B$ y
      default:# D$ V6 X+ `0 e3 F& U/ k. \% L8 e, g
         break;
}% f/ L- s7 S$ v2 W* C0 e
return 0;
}- o. N. D$ n( s# \9 o
7 b% ^# q% |* D. Y2 l, o) p
int isOpr(char c)
{8 D2 b8 M( e9 ?( Z3 c5 d. ~) q7 I
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else 2 e4 Q% n  X' }( D
      return 1;
}2 k1 i  v# Q1 @; h( F9 g1 _& p3 h3 n$ X

float operate(float x, char opr, float y)1 L" M% \9 n, {! q  O6 {( C% p
{8 Q* d% x% w  N* s$ n
float result;
switch (opr)3 Q0 G$ N+ R7 D4 u
{# o; p2 _9 f# v% s
      case '+':
         result = x + y;
         break;' N. O) Y2 _! {) e$ G  N
      case '-': 2 G/ P8 L3 B) u2 P
         result = x - y;
         break;
      case '*':
         result = x * y;
         break;  P6 k: u6 k( ]$ Y2 s8 k; l; h
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;
         }
         else
         {: P3 x' }: t9 X+ ?" ]% G9 S
               result = x / y;
               break;
         }' Z1 K& s' c" [- \* B
   default:
         printf("Bad Input.\n");
         return 0;# |* q( o: L5 ^/ \; M
}7 H, F8 b+ Q2 h( D# t9 S! n% [5 b( W4 e
return result;# j: m5 S* M5 a" g
}
0 d; g/ \+ j  q
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;# R2 {( S) ~5 m0 o6 h( w
char buf[16];8 U8 b! a" H9 U6 {+ a" P6 l
int i=0;. f/ m# V! U. G( r- A1 C! h2 }
) G; @& Y& n( s  C& Q
InitStack(optr); /*用于寄存运算符*/( c; k, g2 l1 p# k+ U+ \
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));* [9 u( x7 S5 ]) p

printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*// v* k* O8 l  ~+ _" O9 W
GetTop(optr,opr_top);0 F) `# X* i- u  u* J
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {' N4 e' x! E, S( a/ N/ x# x% g
         buf=c;
. D( V( B+ V* k9 W          i++;' D3 y" i, K* G' }; J0 I
         c=getchar();
* H6 g" w' r* l* T6 P: y6 A" S       }9 O  s9 W# G4 Q' H9 `. \
      else /*是运算符*/
" d+ A. p, _' r       {- ?+ N! e3 y* G0 F8 T* ?; W
         buf='\0';3 ~# `9 ^+ P9 S+ P
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/( y/ l! O. B6 L  W$ q
         {
  P% r6 c7 e  B8 l9 ~2 o                opn_in.data=(float)atof(buf);% i* Q9 T( ]* D4 @* _; C  w7 E
               Push(opnd,opn_in);" `1 f$ c, O5 W& r# j2 F3 b+ m2 I( F4 F
               printf("opnd入栈:[%f]\n",opn_in.data);
, _9 _; V4 ]% g2 a2 d1 ^# h$ x2 P" M                i=0;" d. x$ c8 k9 U
               memset(buf,0,sizeof(buf));& E: L% `" `( y9 ?
         }7 w/ a6 `: b1 a- |7 t
         opr_in.ch=c;) D/ M. [; O% m" d' M- H* O
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/" t  n. c! v( t/ t2 u; k2 g  n
         {
' X1 S5 j  a7 ~5 A1 f% ~( M1 K             case '<': /*优先级小于栈顶结点,则运算符入栈*/: o0 d1 N  g! ^5 g! f9 V. d7 Y
                  Push(optr,opr_in);# Z- P. U. I8 i+ j) {' n) }
                  printf("optr入栈:[%c]\n",opr_in.ch);
: N6 W% ^* k; V7 o                   c=getchar();
. d0 R, p  P/ g7 [9 t0 K                   break;
& _7 o: \+ f. z8 x             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
7 y# @- G  Y) W! U! X                   Pop(optr,e);
( y8 _" u  F3 R( `- Z                   printf("optr出栈:去掉括号\n");
: ^1 w5 S+ i* z& G1 o6 c                   c=getchar();6 F2 t* J; T8 \* I* e
                  break;
4 e" A% {' ?/ D) Q3 r& N1 J0 j             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
7 W% l* r( M0 g                   Pop(optr,opr_t);
) q$ q# T' I# n; N! o; x- Q5 W                   printf("optr出栈:[%c]\n",opr_t.ch);7 U  K$ H: Z8 T
                  if(Pop(opnd,b)<0)1 w! ^5 d% Z( d6 B2 M1 q
                  {8 T3 R: ~& v1 o3 Q4 _! e" J' c% R
                     printf("Bad Input!\n");' l1 |& Z; V. r! h0 o
                     fflush(stdin);# A) M& T. u$ u  B! {, W
                     return -1;; a7 P/ V7 S- b' z9 j) [+ Q
                  }# H& `! ]  }) V# y: I
                  printf("opnd出栈:[%f]\n",b.data);" E8 I1 b% E7 V: q6 v% X
                  if(Pop(opnd,a)<0)7 y8 b& W/ x1 k2 [  U4 s
                  {) {7 ~  G! N2 j$ ]( M/ N5 m1 K8 v
                     printf("Bad Input!\n");# @5 f& o$ B7 D6 L0 U6 Y: ^
                     fflush(stdin);' P7 t$ X5 s3 N, H" _; g7 k
                     return -1;! n/ E+ \" u0 D( @( [2 a
                  }( i+ |% D2 s4 @8 o& b5 z
                  printf("opnd出栈:[%f]\n",a.data);
$ B5 I/ k  |* L( G% v9 e+ J                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/3 J5 A5 D* @6 U9 k
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/9 d3 y8 M6 y! m9 r9 p
                  printf("结果入栈:[%f]\n",opn_tmp.data);
/ h, X' o7 R3 h- c" J8 C* a                   break;
4 f9 K1 D! k. D# t; n/ r, E* x          }. h) K& J! C; D8 {* v
      }* ]& v! ?" R) r0 m% c5 e
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
$ X! m/ ?/ G8 U5 `! G$ N& ^# R }
GetTop(opnd,opn_tmp);# C) W. r& @1 w5 u6 c- M& n
DestroyStack(optr);
2 ^0 i8 Z# `4 @ DestroyStack(opnd);
5 V5 y  ?5 L, C3 ~. |4 X return opn_tmp.data;
# Y3 T9 g: F3 H}0 V0 I) P/ m4 \+ R" F
, x. |0 f7 {+ v2 F. F! e' m- i
char *killzero(char *res,float result)
, `3 T0 E/ a4 ^' _* O% h{' U" |& v! G9 ^  y
int i;( A9 J% r3 o( s0 U$ u* \* J0 R; ?

) m2 @3 z1 K0 e, E0 q, j sprintf(res,"%f",result);2 t# i6 C& x# h2 q- l" H5 x- r( ~
i=(int)strlen(res)-1;% e: T+ c6 K$ J, q( T
while(i&&res=='0')$ r  a5 Q3 e4 _
{1 A) i: d6 [8 _) \/ ?7 I+ U/ d. k
      res='\0';
6 ^# M- W) P; H       i--;
" P) Y+ ?( ?8 b8 M! q }
) {4 M# d/ [# h4 q6 f7 Q0 s% H/ F/ Y if(res=='.')
; U7 N* |, o5 z. \5 w! d* h! e       res='\0';6 c* e! k1 Z4 L  e5 ^% J9 j
return res;
2 w5 d, i4 D$ J6 ^) Y+ }! C}
5 t+ ]8 ]* g& U& }3 {( F+ M# R/ a% q) K4 p2 D
int main()
- n0 ^$ Z& S1 K$ N{- k9 {3 w2 |" N) Z) \
char ch;
9 g# s* L4 ~" w8 W! Z char res[64];
3 f! M2 Y. e2 a) g float result;
+ g& |5 E' y/ u. c8 _ while(1)/ q5 ]4 \' d3 ], Z: x$ X) ^
{
) ^# j8 n6 ?% o       result=compute();- R3 D7 p1 Q/ s5 V; J3 U
      printf("\nThe result is:%s\n",killzero(res,result));. d2 p* c# r9 z1 \: t1 d
      printf("Do you want to continue(y/n)?:") ;
" Q& I3 S4 f6 A' o% p) M6 }* X; u+ m9 b       ch=getch();+ E' I4 l: z6 P  y0 j; Q8 p' S
      putchar(ch);2 h# r. m3 Q) y/ g+ u$ v
      if(ch=='n'||ch=='N')
/ _$ d4 J8 v4 R6 \6 w8 e          break;
' {0 v3 ~0 K, R2 g       else
, \3 I3 T# Y! K. @' Y          system("cls");
- a6 f, J3 k( ^8 o* P }; h) e# _% L( b6 z. x
return 0;
) H, r& u- {4 v, c; d+ l}& h- _3 a! [' L& w

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

返回列表

C语言表达式计算器

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

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