C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.1 Y& e, L, K5 [! v' T
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/1 d$ _. C6 f6 |
#include <stdio.h>% c$ Z  a8 Q# X. k9 ^# t
#include <stdlib.h>2 r. E, s8 I# ]/ ^
#include <string.h>
#include <conio.h>& t2 w) a! u9 c) ?4 \
#include <malloc.h>5 k6 G! |1 l; I, _, s" @* B" J/ ]
+ e% Q: I/ X. l  w, j" Q; ]
#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{( V/ c6 A9 N) t0 k" r
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/6 \- L' y  t* ^
};

struct Stack{
SNode *top;& w6 J. {& O5 f# ~1 k( ]
SNode *base;* b0 v1 P' v8 X0 w
int size;
};) P# m* e& x: n
1 F( X, R% e4 z% x4 Z2 d) M
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/- E- u( K+ j6 ?- N6 n! D& ~6 S
int DestroyStack(Stack &S); /*销毁栈*/" \# F1 U/ M) c% x* d+ Z: O( k
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/9 J* _0 P4 b! n8 g8 e& L
7 K& ]3 p+ V# {* Z
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/- A& n# j1 ^& t" v/ @% s" V
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/$ J6 T5 j: b4 p. O4 _, E! s
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/7 x4 }! l3 G6 S4 U" [  [
float compute(); /*表达式结算器主函数*/7 K2 J  m0 [- R4 L7 C
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)' j1 s9 R6 y9 ?& [4 M3 }  ~2 T
{' a# b2 u3 d) k/ f2 r
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));* x  z1 L; n5 ?+ h) L1 v* i
if(S.base==NULL)
{& b4 D0 c4 A. z' z! M9 o
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;( H# k  l; g( n+ ~& e: M
}4 \9 C! n  \+ T' ?8 ?# s

int DestroyStack(Stack &S)
{
free(S.base);
return 0;! J* ~7 z! r1 g0 w8 j7 C
}: @5 [. z0 k: N8 K  W( n+ H

int ClearStack(Stack &S)" K1 a0 v+ G, h7 @5 R8 k, R+ v& p, d+ j
{1 V( V# P3 }3 s+ n, R# ?# ]
S.top=S.base;
return 0;
}
3 `& q0 A3 _: a& B
int GetTop(Stack S,SNode &e)2 }& z( y2 H8 J$ \* k
{
if(S.top==S.base)
{/ t' ~. P( G: l! I4 {4 t
      printf("栈以为空!");
      return -1;
}% v5 l% H* l# g8 Z8 s; H6 H* ]
e=*(S.top-1);/ g9 u8 Z( q- d* P' J2 D
return 0;
}! K. e1 i$ Z3 R2 _  y: X1 Y
1 L- x4 B& g% `" [( N
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));0 G) a6 q- [( z8 Y
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;- F6 h: X! P% c/ y# A) W4 h. k9 z
      }) @1 l) k. C9 Q
      S.top=S.base+S.size;2 g/ B6 O+ r1 y7 v
      S.size+=APPEND_SIZE;
}* h1 J$ \* `9 \; |% ~
*S.top=e;
S.top++;6 j& s6 t7 Z/ z: L
return 0;
}
  m  ?8 k" t8 I9 X1 v% u# b
int Pop(Stack &S,SNode &e): e3 r7 o# `6 d
{
if(S.top==S.base)
{
      printf("栈为空!");8 @0 ?5 e0 s7 }9 a8 D* \: ]; R) o' A
      return -1;  k2 t! F4 G% K' s. x) \+ [
}. ^( u; r: R3 Y$ |; T  L% y
e=*(S.top-1);3 Y, P8 |3 h6 v8 V% z
S.top--;
return 0;6 x: q; M6 P" o% I; w
}( M) p8 ^( {- j' ^2 t- X- \9 t' j: Y
5 I6 T9 _  P- @" q. M9 F( X2 ^* T
char get_precede(char s,char c)3 U8 ?1 |; U, x& o0 x
{/ h1 M4 B' W# |
switch(s)
{
      case '+':                / U- ~% k' X& \, U1 n
      case '-':5 L/ K2 \6 E, |+ c! j1 O
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')3 e' |! u- A# C- N# s$ u
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';. s. |% l; C" [9 g+ Y
         else ' i. e" }8 |2 V; b7 w" J& C
               return '>';& t! N' @9 T8 N: _3 E  n% H
      case '*':$ u3 Q; _2 k1 O3 o/ b, A
      case '/':3 U0 ^$ O* }# \/ S+ n% d
         if(c=='+'||c=='-')
               return '>';& j: X; C7 Z0 [8 H
         else if(c=='*'||c=='/')9 z( a5 l7 @( X5 ^/ O( s
               return '>';5 v7 j3 x! S/ h. H+ C) C
         else if(c=='(')
               return '<';, y: F6 g( ]- Y% y6 Z
         else if(c==')')2 I. Z6 x) A8 i; B7 J
               return '>';* K6 \, I  x  N  t* b
         else
               return '>';& B9 x( _) T' f3 p
      case '(':
         if(c=='+'||c=='-')1 c8 k. ?$ l" l! Z+ Y6 [" ~, c
               return '<';
         else if(c=='*'||c=='/')+ W' P& E9 g6 c& a; V- V' ?8 l
               return '<';
         else if(c=='(')7 Y) u  }# |$ j# j! O
               return '<';
         else if(c==')')6 a, M3 X  ?  X- W: Z+ d, l" G; e
               return '=';
         else
               return 'E';
      case ')':# n! }4 ?* U- H" G. o8 Z5 ]9 A
         if(c=='+'||c=='-')+ X$ f% E) C4 }, B% Y
               return '>';( G% m/ A" Y9 u4 t' v
         else if(c=='*'||c=='/')) {9 i: L; S, U! k( G% n
               return '>';2 @6 U5 ]" I4 ?( S% U
         else if(c=='(')# U, ]9 O9 G, q, o3 _
               return 'E';
         else if(c==')')! F  B0 L- _" p  w: Y5 z$ i, v
               return '>';- M2 q5 V, n6 J* z) [6 F0 X7 G3 Q
         else# P3 S  L; b$ H3 M3 Q) H
               return '>';
      case '#':9 T* B+ I% K: b
         if(c=='+'||c=='-')! ^6 E# q5 m5 ^; z) j
               return '<';$ R$ k$ N$ K' s2 a8 C
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')  H. [: O# Y, ~5 W
               return 'E';
         else+ o9 E' H  G: `' D+ w! O
               return '=';
      default:
         break;
}6 N- F& {) A% D- ]7 E1 r
return 0; - P1 Q: H! d) u
}

int isOpr(char c)) }6 K; n% a4 g/ G% A4 |
{5 ?- {3 W9 b' C4 }- V
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;7 |+ r" V, ]0 [* y* ^
else
      return 1;
}" |1 K, L$ E: X4 c& I2 b

float operate(float x, char opr, float y)/ i  A  A+ i" p( P* t- L
{
float result;
switch (opr)% q1 F3 T4 }9 a2 l. o
{
      case '+':
         result = x + y;
         break;
      case '-': 6 ?2 ]' I8 s0 Z7 |9 G
         result = x - y;+ `7 `' l) b- b
         break;5 E; I2 h, [# X2 H; w6 m
      case '*': / B9 H7 \# [1 t  Q% i
         result = x * y;/ \- a$ d6 n% M' r
         break;! }/ O3 h, C/ S. P+ a9 r
      case '/':
         if (y == 0)
         {9 I2 f9 ^$ i/ o
            printf("Divided by zero!\n");
            return 0;
         }
         else
         {, O8 R% Y  l9 d
               result = x / y;
               break;
         }+ B3 W( E) J5 `+ U
   default:
         printf("Bad Input.\n");
         return 0;/ d8 H! ]- |) `2 v/ j4 [% @% Z
}  Z6 {& B$ ?$ |' N7 l( `( N. e
return result;
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/8 V( T3 m+ Z/ i& T
{
Stack optr,opnd;; m' s; u& [1 e. e1 n7 }
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;, M! g: B2 d! L7 n
char c;
char buf[16];3 ^! u# T" f$ b2 a% _* v" Q5 @' K; F" z
int i=0;/ `6 |" ]4 m/ w+ }& o
( }% X; ^3 s* i# Q4 a
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");( T1 O* D4 q9 z" I7 x; [) S

opr_in.ch='#';% W; W, o6 x: m5 O: s8 w
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();3 O- |( E" r% Q, i- [1 T
while(c!='='||opr_top.ch!='#')' F8 r! N) Q) ~$ o
{  m0 Q' G& v3 ?0 p* _
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/# l3 o( p: m$ u3 t
      {
         buf=c;
1 K% G# Y' K+ e4 q8 k% E0 E9 P" b$ ?4 l          i++;! }" H' k+ [: ^
         c=getchar();& n& C( y8 y) I$ }" k
      }6 K4 i3 k8 k& d4 ^6 z  s
      else /*是运算符*/( F) T5 ?1 m4 k1 S, m
      {5 j! v; C1 D6 q/ ]2 Z. `! z
         buf='\0';/ h$ k0 {- K% Z8 [
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/+ v  j5 j  W! [5 k6 ]
         {  z' d! i! \4 o# w
               opn_in.data=(float)atof(buf);( o$ a: |7 Q5 e7 V1 J7 v* b
               Push(opnd,opn_in);
( y6 }/ J7 t9 ?% L                printf("opnd入栈:[%f]\n",opn_in.data);( l* ~: d) ~7 v6 A" Y  M4 V; e* a
               i=0;
! s1 i/ X. j) O/ ~                memset(buf,0,sizeof(buf));
' Q5 ~; ]' w! M; ^/ M5 n          }
! s3 _1 |( z  Q0 A- ^2 [          opr_in.ch=c;  X5 L- q+ q( G2 ^. }' p. ]
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
$ j9 ?0 C0 K6 I4 l+ q; J          {
( y, a5 F  |4 I& A             case '<': /*优先级小于栈顶结点,则运算符入栈*/
: `, R7 a6 Q) ^: l. L, s* v                   Push(optr,opr_in);
4 ^3 A# {7 S* z; N' G, Z; J                   printf("optr入栈:[%c]\n",opr_in.ch);5 v; \2 U  p) H" w. T
                  c=getchar();7 z5 x; s' k/ M# b( Y: n4 U
                  break;
6 [/ J* r, v) I7 C             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/& J! @+ Q4 p* V% K# v5 M
                  Pop(optr,e);5 t. \) Y. n' m! x$ J- Y
                  printf("optr出栈:去掉括号\n");
( z( a- T' H6 B5 d                   c=getchar();
; z" k! Y' E8 y: u% Q% G# n: A                   break;8 c7 t$ d7 r7 _5 t
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/2 P7 S' Z6 ~  O3 {: E
                  Pop(optr,opr_t);
: n  c8 Z% F, U& p5 K                   printf("optr出栈:[%c]\n",opr_t.ch);
7 q; d" r5 t8 Y& D) ~7 T6 p$ H                   if(Pop(opnd,b)<0)
/ L, y+ |( A0 @$ R9 e* k- J1 ^                   {8 Y9 f' v- B( M0 F/ B, ~% F
                     printf("Bad Input!\n");
, z: `5 k' R; N6 X( \) f, T1 f                      fflush(stdin);4 H% K# _! A6 U1 }& ~- J
                     return -1;& e5 F" f) Y2 X8 X/ ?
                  }6 Y1 f9 |4 T3 B- U
                  printf("opnd出栈:[%f]\n",b.data);
7 v$ i" `% F, r# ~0 Q8 ], I! P2 X% G                   if(Pop(opnd,a)<0)
7 }! m6 O7 J* ?) L1 r1 S  X                   {  H; J8 e( I% j4 k
                     printf("Bad Input!\n");
4 U6 L+ c8 q# I, f% B                      fflush(stdin);$ W7 s  d! U4 u, B& Y
                     return -1;7 W! r& f1 J2 k  o) k
                  }3 Y9 @' I; b0 `; I, z5 [
                  printf("opnd出栈:[%f]\n",a.data);
8 i$ @! p' N8 |' h9 A& @                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
) O8 S6 u5 i5 G; Z+ K9 R# S- z5 x                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/0 r+ Q% k! g$ Q. ?0 O
                  printf("结果入栈:[%f]\n",opn_tmp.data);7 O( \, ]' ^7 v' x- `( W
                  break;
2 Z3 |( c9 v. ~2 ^          }
0 J3 r4 m9 y) m, p+ P( K0 y; n       }# L& D' h+ D( I3 I
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
$ w6 Q3 H6 K! F  O5 G9 ~% Y7 K! A }
$ _, _) `* h  q7 ~: g GetTop(opnd,opn_tmp);0 a5 e. d- p* b5 t& N* @/ W
DestroyStack(optr);4 }/ X0 Q- L. U  r
DestroyStack(opnd);
  c. c4 r* H* y) }; h8 f& Z5 p5 w return opn_tmp.data;9 T3 ]2 G$ X3 T- {2 k! A7 v
}- A/ {+ A" R: _- i# u! L

# Y) l6 z% M6 w! b( cchar *killzero(char *res,float result)
+ g. }4 ~7 _7 c: o3 ]  E( q{7 d( ^& |0 I5 e7 X+ y/ L2 f
int i;1 T- Z. ]0 w2 k9 \. X/ x/ M0 b, J

* K4 c. p- U* ]6 c; n2 K5 |+ t sprintf(res,"%f",result);' p* Y- B/ h7 f0 T
i=(int)strlen(res)-1;( D2 x& X4 i# C- v( J' d
while(i&&res=='0')) Z, u9 K$ z6 M2 |8 _7 h5 S$ J" H) K
{. S% L) ?+ i+ C2 O" U
      res='\0';
( w- L  \, H1 m; L6 n) M       i--;
& m: E/ z/ @/ G+ d/ G }6 m4 n* r' d: g" Z8 J! c2 P+ |
if(res=='.')4 ^( B  _; V. I7 H
      res='\0';
* c# M' b* J+ U3 T2 _ return res;
' k6 |' w, |+ I}2 g) z8 A( M7 j  P6 U5 r8 [1 T
! C7 N: d  `  d
int main()% V' r, Y. [' y. X! R: M" G
{3 u( U: {0 I- b; S
char ch;! B+ f* o  R' C( J3 ^2 ?6 Y7 g6 ~
char res[64];' C; P4 `$ M# V; d
float result;5 g2 F" H+ P9 d$ d7 B% v0 u
while(1)8 I1 l( [3 M- x. u4 d
{
5 g! m3 |) u' S       result=compute();
0 O" ]! f) V% u% S% M2 v9 Z4 U       printf("\nThe result is:%s\n",killzero(res,result));
. [* Z* ]' H' z. q, S% A       printf("Do you want to continue(y/n)?:") ;* @6 q4 `8 `  o+ M
      ch=getch();
5 R: N; r; }) I- @$ W       putchar(ch);
& G% i% z3 k$ q9 O7 k/ H       if(ch=='n'||ch=='N')1 w2 x# ]' W. I- t
         break;! S) N# v, ~! L5 O8 l
      else
. P$ c+ K+ [& O6 R          system("cls");0 {0 H% d, d3 J  I/ i/ }
}- N+ H. V/ Q$ L# v/ w1 R
return 0;
/ T! Q( [/ i+ x! b% h$ A4 X}' O( L( y6 v+ Z4 v. [- L
: S: t. r- v& p7 [3 z
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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