C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.; V- m. H( j9 g2 A( w
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=. M' ?7 a9 w0 z' b: O) z9 t
/**************表达式计算器************/. h! s/ F; X+ @8 f/ e0 D$ T1 g
#include <stdio.h>
#include <stdlib.h>
#include <string.h>& f) J7 W! Q/ d0 @( z
#include <conio.h>
#include <malloc.h>
+ y" A6 b7 X8 `& c; S% h; j
#define STACK_SIZE 100" i0 i2 d9 |* }. \) A5 M
#define APPEND_SIZE 10( V  q; R% W& g8 K2 t% X

struct SNode{1 K" Y" t9 y- \# J, J
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*// g1 v, @# X1 v" I: U
};
2 t$ i1 ]3 V: M. N, o+ Y0 k
struct Stack{
SNode *top;- a4 E% x  ?4 C$ {# ~* V9 W
SNode *base;
int size;7 {7 [9 j  Q8 s  P1 G6 ]
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/. X4 A8 O: Y+ D, z) F
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/7 k+ `- t( X' J4 k% b" T
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/2 w% K) p; R/ W; f# |& O
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/9 b1 [: L+ f8 n$ q% ^  n1 K
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/: Z: ]" @- O( ?6 V% Z
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S). s! j) X! P. ?0 a
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");, k# h: n' ?& W, \4 l9 R! R4 u( O
      return -1;
}6 W. v' z3 D! O4 O( V; a! H5 }2 l+ t
S.top=S.base;
S.size=STACK_SIZE;0 F/ f( t9 f5 H1 ^! I: w
return 0;' I$ ?- q' L* p# h
}
5 j" ~- q6 u+ O: D# C4 h2 h( f
int DestroyStack(Stack &S)
{7 [' E6 e4 v# M
free(S.base);
return 0;
}6 O% E5 B5 I* `; v

int ClearStack(Stack &S)( P5 T9 ?1 m3 W( p) p
{3 J2 d) t5 O' K& _, B6 I
S.top=S.base;
return 0;$ q, v9 h6 ?8 _9 O( z' V( y# ]
}

int GetTop(Stack S,SNode &e)
{3 ^3 q9 d/ {4 ?8 A
if(S.top==S.base)3 g4 H' ?1 u0 ~  h8 C! i
{6 A$ a8 S0 t3 j4 k5 d, I8 X
      printf("栈以为空!");1 e6 |6 U6 ?* E4 g
      return -1;
}2 G( ^2 W" r/ b% X  Q
e=*(S.top-1);
return 0;/ U: R1 ?% f4 M- U  K
}
' T; v1 Z$ }2 `7 c* [
int Push(Stack &S,SNode e)
{: r6 k& p2 O. _7 `* A  H) u1 D
if(S.top-S.base>=S.size)6 q6 q0 p7 z; [& l8 B* |: @* y
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));/ L/ P7 B1 q: D% w+ u
      if(S.base==NULL), D( j/ \+ v6 g
      {$ c' E' u8 f& u7 n
         printf("动态分配内存失败!");2 P1 S$ Q* X, M+ J' g1 N2 P& v
         return -1;: L4 W& X4 S9 I0 w0 |- U& f. J
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;+ o8 D3 k  P. i) v
}
*S.top=e;
S.top++;
return 0;: V0 h1 x# S" F5 |- `
}# M. u2 A1 M! r# i+ C1 O
5 O0 E) Q4 s! x1 ^9 ~
int Pop(Stack &S,SNode &e)
{% ^, N& S* ^' `6 y3 }& O% b
if(S.top==S.base)! t$ h+ i- H! ]8 s7 D7 {+ P- R# _
{) X0 I9 @' M& O1 v* p3 ]
      printf("栈为空!");: O" e% N: ^- s! l" Q8 N
      return -1;7 F+ m; a2 k& q; t# A6 C
}$ m  a4 ^( B( ~: Q
e=*(S.top-1);
S.top--;
return 0;6 I5 U7 `2 U7 b# ?% y" l( L$ z
}3 s4 I' Q  N" h8 k

char get_precede(char s,char c)
{& h* L* D2 F1 V, K2 ^+ G
switch(s)
{
      case '+':
      case '-':6 q3 l0 }9 \& t! R% p8 j3 h. A, S
         if(c=='+'||c=='-')
               return '>';9 {6 l4 K" |, ]( B" B# C
         else if(c=='*'||c=='/')- ^: S3 N$ v% \5 W
               return '<';- ^6 L6 L6 ?. B- C, ]+ g, a
         else if(c=='(')0 }  v* \- H. ?4 P, O
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';
      case '*':7 u) j( x3 G. g$ v  ~  ~
      case '/':# O1 r# `' }# @5 j& y$ o
         if(c=='+'||c=='-')- k# ^* t5 Y. g
               return '>';5 y3 l( d1 ]2 R1 P% l  ?7 M' `
         else if(c=='*'||c=='/')
               return '>';$ p9 Q$ z" s4 f, F, k
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';3 P- O; b! W+ v2 e7 h
         else
               return '>';
      case '(':) N( Q( x: o2 v; N
         if(c=='+'||c=='-')# N) w3 u2 ]8 z! `+ G
               return '<';9 O1 ]  H1 @: Y6 W& c( D
         else if(c=='*'||c=='/')' I; S" R3 ]. {- P
               return '<';/ r: |  [4 g' G4 a3 n1 C1 G
         else if(c=='(')* d: J0 _) f: p* e
               return '<';# @" g; z7 G- n1 |2 d( `8 Z
         else if(c==')')
               return '=';) E' c: _7 S; c: u/ f" u
         else9 j& f, c" `, z6 a1 f3 \
               return 'E';
      case ')':
         if(c=='+'||c=='-')2 Q) C- Q4 g8 b3 E9 [
               return '>';5 a- V' W& M4 a/ s) B
         else if(c=='*'||c=='/')
               return '>';: W+ s! V$ @, @; K4 x
         else if(c=='(')6 c5 f/ ~+ C% n
               return 'E';, x  B6 l2 e# v$ j) Z' `
         else if(c==')')& }; S! L, G% u5 j% }/ {
               return '>';
         else) o$ c/ y7 n' b$ m1 o
               return '>';) o; H" G6 _: x, T4 ]: y
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';7 d3 }3 z- R8 i9 Y3 \: `; l) ~) H
         else if(c=='(')  Z5 Q1 l+ v* H' r# f1 Z
               return '<';* k4 e, U" Q- ]0 w( W+ W
         else if(c==')')! Y4 h7 o8 O% _# R* t8 \% c. T4 x
               return 'E';8 n% l+ X, N% o9 M7 u
         else
               return '=';4 u+ ~, p1 O: {% P: R. U
      default:, y* h7 P& D, C/ j' z( U
         break;4 v- z, t' o: O6 ^0 \' R1 m. r
}+ }) a/ {0 e; ~5 s+ w7 a. e: m
return 0;
}

int isOpr(char c); j$ F, d5 ^' K/ s% Q" a$ f/ F6 k
{% o' Q4 r/ Y7 k4 o3 x4 }1 u
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;( w+ Y+ v" p8 h1 p% k8 @' L6 C5 ?/ c
else
      return 1;
}
; L" @$ j$ ~* a9 d/ t% e
float operate(float x, char opr, float y)
{  K& Z9 U1 L& Z9 h! B
float result;
switch (opr)
{) L+ M# G6 D" n4 d
      case '+':
         result = x + y;
         break;
      case '-':
         result = x - y;
         break;
      case '*':
         result = x * y;
         break;
      case '/':
         if (y == 0)7 e: g( K. y, K" R! o% _' s% e
         {: P" ~' n" c/ e) ]; j9 e: L' x
            printf("Divided by zero!\n");/ V) q5 `2 K% C
            return 0;4 `  Z! w: ~# L8 }4 {' h6 d
         }" w3 u) e7 p4 d
         else! O  Z; c- i2 n- U" l, H9 _' ^+ y6 o
         {
               result = x / y;
               break;
         }
   default: ; J  K" V% ?) |
         printf("Bad Input.\n");
         return 0;7 @, _  \1 V" c+ Q) d* I- I" a+ {. q
}
return result;
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{3 T. y( [9 }! W8 ]2 I/ Z5 N
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;+ W# \4 C9 t- q6 c8 E- d
char c;
char buf[16];& j. ]& z7 C$ I) \+ c
int i=0;
9 h; k! m, J" ~1 C- P" y
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
0 c3 n% a6 x7 q# H  E! |1 Z0 A9 N
printf("Enter your expression:");* u) {1 V# D0 m* n+ e. x! d

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/( R+ d; _2 k. U9 _5 ]4 g! [6 I8 k) y! X% R
GetTop(optr,opr_top);+ C9 X6 h9 c2 ~' [2 [6 v' y) E
c=getchar();
while(c!='='||opr_top.ch!='#')
{; y: G3 [2 I/ h, Q; W
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {! o" z# A/ c( L. f
         buf=c;
6 {# B: M" g8 K& [" s  W% w) O, S$ Z          i++;
: [( q  D" l$ _) u, J9 X: ~          c=getchar();
9 l5 Z; w/ M9 X/ P4 [3 R       }
% M: R, ]4 V4 E       else /*是运算符*/7 R7 i  a. C/ D" g
      {
/ y8 E1 N# W! k' C5 G8 F          buf='\0';
1 l+ p2 O) e+ [- }( H          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/0 c8 w' [7 n, m2 ?# B
         {4 ?5 i4 o2 `; @8 n+ Y8 s
               opn_in.data=(float)atof(buf);  v+ Y- I9 I/ o0 q# T; o0 k
               Push(opnd,opn_in);
; }9 h. ?$ W+ q! x- J                printf("opnd入栈:[%f]\n",opn_in.data);
# g9 j$ u8 ~  e                i=0;
% H: f- a7 T+ f4 x                memset(buf,0,sizeof(buf));
0 a7 u1 j( r: P* |$ M          }
6 w# W; P8 }8 x' |6 K1 Y0 I          opr_in.ch=c;
8 X4 _2 z/ N& |5 G  @7 z+ c          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/4 b/ C9 M" O; T9 y
         {; \# K4 _/ e2 c  k7 ^( X) M
            case '<': /*优先级小于栈顶结点,则运算符入栈*/4 K2 o0 P. ~* M4 \: y  P4 B
                  Push(optr,opr_in);: y- G* H' }& t: }& K1 o
                  printf("optr入栈:[%c]\n",opr_in.ch);
6 @3 e3 e& O7 J% Q% S" s0 _; N& H                   c=getchar();
4 O( h) l% S2 C( w, Z. g# [                   break;
0 I1 H, Q) ?# ^% e* [4 l% Q             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
' J" `0 p1 b3 H* M- V: o4 ?# M                   Pop(optr,e);
' ?: F8 A  _$ P* [                   printf("optr出栈:去掉括号\n");
$ ?1 X/ O, H! q9 h) U% ~( |                   c=getchar();
9 m# I% Q! c& X9 j% z$ \- ^                   break;
& f0 U8 P% q+ ]# l1 g             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/) r1 h0 N7 Q+ m
                  Pop(optr,opr_t);
+ n2 `' _( x4 w6 {" G) {( N                   printf("optr出栈:[%c]\n",opr_t.ch);/ S/ k' R6 \3 Y
                  if(Pop(opnd,b)<0)1 Q/ l8 w4 P" ?( e
                  {
* B) q# R' D  ?3 F( h: ?                      printf("Bad Input!\n");
% u7 t' F# Q1 g) \$ ^* Q1 q  w$ p                      fflush(stdin);
8 M& R( ]: }3 v! F: g                      return -1;" }, z# {' f% H
                  }+ d. M/ [2 w- l3 c0 ^' c6 F
                  printf("opnd出栈:[%f]\n",b.data);: f$ S$ V( n! `  b
                  if(Pop(opnd,a)<0)
7 p& o  v1 ?' Y0 E! S* W( B                   {) T0 R" x" g6 F7 ]0 j& A: N+ V
                     printf("Bad Input!\n");
- G, U; m8 j' v3 ?                      fflush(stdin);
, Z4 J: u0 w: ^9 j, e3 [# l: ^                      return -1;
  E. F/ {+ N% w) ~                   }/ \; H6 N/ ?; q1 u+ e' O
                  printf("opnd出栈:[%f]\n",a.data);5 |" _% G' _+ e3 E
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/, }$ f7 J$ z8 a" Q' j6 c; L
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/- X8 u+ @- G! s4 l
                  printf("结果入栈:[%f]\n",opn_tmp.data);; n# c* |7 T- B) X% n9 Q: x" e0 B$ A, p
                  break;5 N9 l* G7 j; Y  J5 W
         }* g  M; C( U* O! s
      }9 l' U9 y* h4 S8 I
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
8 U9 x( a8 H; _! Q& {- J }% p  g& d$ w  q5 S
GetTop(opnd,opn_tmp);7 v0 V* O" e+ C3 e3 |- x
DestroyStack(optr);
. n8 @3 n+ f: @' S3 l4 v7 [/ ` DestroyStack(opnd);5 G8 r/ T8 G- G: i  N& R5 y
return opn_tmp.data;
: G: O7 K! _* h* g. w) G}
* S1 y0 W9 @/ f2 ^- t' b# V; T# A. b" `3 f9 |- k
char *killzero(char *res,float result)
. W) U6 a3 O- ~8 p" k) s0 o" y{
5 `: B- i0 Z5 B7 a1 h int i;, J8 n6 I4 V: Z* t+ n

2 L5 [  p) U* D" _$ m sprintf(res,"%f",result);% S; ~0 n+ X' |; I& G) z1 e
i=(int)strlen(res)-1;
- |- E3 c4 o" o' u  }8 q7 N" k while(i&&res=='0')
' l" I3 ]* f) K# r% j {6 q, V; {9 u+ r  C% F3 Z3 T7 E
      res='\0';7 d3 N' F# @; h$ \$ m: U
      i--;/ h1 d$ ]9 s. F: S2 l" Z9 Z
}
2 L5 c, h# ^3 M$ ^# e if(res=='.')
0 b* n& h* T0 D, h8 P# i  r       res='\0';
8 W, a! f/ S* ~+ [6 L return res;- e4 M* @  m' j* c- b
}
! A9 \% T. V& a: p, f4 U
  ?) y) e6 `5 iint main()
" G) ]0 Y' U' q, N! E{$ w: f& s: k, O- n
char ch;' _$ m! p& J( ?: h  ?
char res[64];' r2 i. O% w3 l8 ]3 v2 O% K  l) Y! i
float result;* M- O. d7 w: }" k' v$ S# ]
while(1)
& ], T7 b: X$ C+ x* l {1 N9 J/ n4 u) M, ^' r( N
      result=compute();* `6 m8 \; f' p! |/ [) m
      printf("\nThe result is:%s\n",killzero(res,result));
# |4 E. O9 V' q2 ?( D& m       printf("Do you want to continue(y/n)?:") ;
3 P/ i1 P* i7 q* u; y' z9 T7 g! r       ch=getch();0 s- a& c2 a: r5 q( A2 Q
      putchar(ch);0 w* t) e" w! I3 D- _, s9 [% \
      if(ch=='n'||ch=='N')
" R! G9 ^2 W7 a          break;
: T, W6 W& U" u; C! S9 ?4 X       else
2 v7 C- n: {- z0 f5 D% Z6 Q% d5 ~          system("cls");
9 F- H1 I5 N2 O7 a! P( Q; i }
- k' g7 {8 H8 r9 D9 ]/ k return 0;
& }* L; ?0 M3 ^7 |* l  Q. G}
/ q4 p4 s5 I/ ]/ L2 @: A
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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