C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=) m$ `& I( P2 @* o; k
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>$ m9 p- E( f0 k. _# u
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100
#define APPEND_SIZE 10/ d# z8 W3 `) f+ o6 D2 T  r
7 I0 R  F5 k5 S1 j
struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/8 q1 n$ d7 b) C8 @) _
};* z- T% K2 ^3 T: b1 z# S4 |

struct Stack{
SNode *top;5 ]7 E: Z, P7 L% L4 q' n/ ?+ L2 H; c
SNode *base;% t! e0 _2 t# w" o1 U
int size;
};
( Y! {3 c2 |- F5 j* E( A# o
/*栈操作函数*// J  R% V$ \/ f# j$ r/ \5 G
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/! D0 k# C. q- x, ^
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/: C0 O; [* M) _$ b  U( v! G2 W
8 v4 t, y2 ]; J/ p$ G: m
/*表达式计算器相关函数*/1 s& D0 F0 j& ^8 K" A5 w$ o
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ # y; k) ?9 M8 f; s) ^6 w1 E; s" }# O

int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)0 S8 F/ L% d4 d' C4 g( w
{: X6 b" {( W  k( a2 o3 U  T0 w% ]7 \
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;# a- `5 P2 f7 B
S.size=STACK_SIZE;
return 0;* t' A0 g0 ^0 `) n" w/ m/ ?7 P
}

int DestroyStack(Stack &S)& e+ `. k5 G0 X
{5 }$ l+ d8 J  ]; g6 O2 |0 z
free(S.base);- |" m4 V; X: Q/ ^/ _
return 0;
}4 s0 \; @" e+ d2 |, E  n9 Y0 ?

int ClearStack(Stack &S)
{% V$ w% k! ~" X: \; Y4 z# C9 \. K
S.top=S.base;8 M! v3 ^/ V+ c/ j9 e  _
return 0;( w0 V- Q- \$ {1 c, b
}/ }4 z, ~! }/ n  s& z8 f
7 S4 M1 C1 B) K/ G
int GetTop(Stack S,SNode &e)
{8 S7 b5 m3 M5 t9 l- a% w; B: X
if(S.top==S.base)5 b, L2 L9 x: w  F/ R* u
{* i( ^* g, Y9 V
      printf("栈以为空!");0 M" T) e# d( w/ t- K, @/ Y4 N2 e3 X$ n
      return -1;
}
e=*(S.top-1);
return 0;
}

int Push(Stack &S,SNode e)8 }. v4 K- f, b$ o" C2 Z4 }
{' p0 i8 o: S; D; s% Y7 l6 w1 Z
if(S.top-S.base>=S.size)( s! g7 c  T1 `7 N' Y! h7 S. Y5 ^
{  G; W  O; U4 C
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));: P2 |5 t+ l+ x7 G, @
      if(S.base==NULL)$ h! w, i: i  E* U: u4 v' ?) L
      {
         printf("动态分配内存失败!");
         return -1;2 h% ~+ F3 l9 Q- @
      }+ l# r7 `* M' o0 U! i  D
      S.top=S.base+S.size;5 b( P- U" i# Y. t
      S.size+=APPEND_SIZE;
}$ w+ Z6 X4 l# R/ L
*S.top=e;
S.top++;' R8 @% o4 K7 x$ h( }  d1 }
return 0;
}9 k+ ^4 p/ K, d. k/ c- i  J4 v3 W9 E! H
$ E5 p7 z/ Y& p
int Pop(Stack &S,SNode &e); ~& g8 L. Y" G! n! ]9 {
{
if(S.top==S.base)
{
      printf("栈为空!");2 s+ D6 `) }2 ^% Q) t$ F# J
      return -1;' m6 p0 R: A* _, M& v& x
}; a% Y# x+ O) A* T2 V0 U
e=*(S.top-1);
S.top--;+ e7 X* o% u0 S% c9 ^+ |4 J% b7 U
return 0;
}
- H2 s! q' P& L. u
char get_precede(char s,char c)- k; H/ H) o" W: G0 \2 g; Q
{
switch(s)5 Q% [% X: S7 B
{
      case '+':                # |5 W4 p$ X2 _1 A* K# K
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')) y: x6 G. M) R+ [' ^0 ~6 j
               return '>';
         else ( }4 F+ S& _: c" b* Y- e9 w8 w
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')/ [8 t& }3 S9 a1 _5 d1 [" y* ]8 g
               return '>';( U; X& P' e8 b0 f
         else if(c=='*'||c=='/')( h2 ~3 ]$ i" N2 @# w3 c
               return '>';
         else if(c=='(')( Q1 {! Q' o. y7 K
               return '<';* S: @) f: o( V! g; F
         else if(c==')')$ N7 T9 R8 N/ F2 d: A
               return '>';$ m: x3 n7 A; s3 k
         else. Z* I$ V$ A* {2 P( [" z( k8 l
               return '>';# P- k4 V' z1 Q$ @) g8 }
      case '(':
         if(c=='+'||c=='-')
               return '<';6 Y1 T8 r% z, M, P( N
         else if(c=='*'||c=='/')
               return '<';, w5 }2 G& r" j
         else if(c=='(')  M  _+ w2 w2 F2 x; g4 y
               return '<';) ?# i# |( ]* i2 V) u, \
         else if(c==')')
               return '=';
         else1 a& [$ C3 H& B2 q8 R& J
               return 'E';# S! d; S: ?1 j
      case ')':5 X2 Q$ V2 w- T* ^; \
         if(c=='+'||c=='-')9 K" A9 s: p2 l* C+ p# f
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';
         else if(c==')')- B+ s* H7 ~- B! z& D
               return '>';
         else
               return '>';* O. O1 X; r- ]
      case '#':. D! h6 Z3 x! e& i( o
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';: z2 g  a/ s  m. q
         else if(c=='(')/ |' z3 m8 e7 Q2 U2 \# v# \
               return '<';2 X4 `. |9 l7 S+ z- u& s
         else if(c==')')
               return 'E';
         else
               return '=';
      default:, R( H* X: }4 S2 Q" @+ J" i
         break;
}
return 0;
}
: T$ S* }7 p' V: M% F+ i5 I
int isOpr(char c)# Z( o: r; {+ |& g
{& G6 i1 ~- c2 N7 i
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;# x. r9 O, d6 ]6 H
else
      return 1;
}
( B) U5 F0 |- x* c. B
float operate(float x, char opr, float y)5 d  s0 P" k# t7 H
{
float result;
switch (opr)$ j; d# P' Z$ h
{
      case '+': 6 E+ {! j# [" e0 H' M8 W6 y) g
         result = x + y;
         break;( z0 |5 [3 B+ {* ?- s
      case '-':
         result = x - y;: o- n2 O4 N. a
         break;
      case '*':
         result = x * y;. c1 S0 I7 s7 T7 E+ C* f7 V4 v7 F; O
         break;& X; j6 ~  n9 V7 @/ e
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");/ ]/ L, t! V3 u9 _
            return 0;
         }
         else+ ~/ _: i6 a: G
         {
               result = x / y;9 X7 A# ~8 f) [1 L* l
               break;
         }
   default: ) O  k& ]& e. V" y  @8 G
         printf("Bad Input.\n");
         return 0;
}
return result;
} : ~/ G* @) i6 M

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/' N) U- C/ P8 I- d
{% f' \" c# e$ z$ b' ]
Stack optr,opnd;- S/ k& I  j- H- _: F
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;: z& V3 R% q* U$ y8 L3 H7 ?
char c;
char buf[16];  o% I. _4 {+ E/ u& A1 L
int i=0;
' ?3 V" O. F( _
InitStack(optr); /*用于寄存运算符*/$ [9 D+ y: Q- y2 @6 H0 M9 D1 g" j. p
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));* L6 I8 ^1 p; s$ l) c( B3 o" L0 v# l% R6 ^
" l6 @# ^; n* v* T5 v9 ?  S; q
printf("Enter your expression:");
      9 P# i& B* a1 b% T+ Z- v' J
opr_in.ch='#';/ D6 \7 t* ]% f7 p0 E2 F( X% e
Push(optr,opr_in); /*'#'入栈*/6 g; A2 S* z$ U( c- f1 A
GetTop(optr,opr_top);# ^. ~" r7 @2 j2 d- p* }
c=getchar();6 `! Y1 o& V) Z2 U2 }8 R
while(c!='='||opr_top.ch!='#')* N0 R. ^7 E" H1 I* F
{* M# X! f4 I+ C  ]$ Z
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/* E6 ~5 N. A, i: `
      {: [, C! m1 M- ^. Q! i! o' @
         buf=c;
4 M, Y( d4 m8 Y; {$ |( u          i++;" P- F$ j# d5 P& m' f: u7 e# `
         c=getchar();5 {; o  l8 B; i
      }' t+ @( n5 N, n) P/ S2 V2 c: c- f
      else /*是运算符*// h- O. z& M* ?
      {
0 ^6 g) w: S! r5 B9 N( ^0 N' V          buf='\0';
: e  p5 T# T$ e2 q7 G          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
" `3 v! N4 T5 C3 A1 e2 K0 ^          {
1 V5 |7 b5 P4 G' o3 z* I& q, ?                opn_in.data=(float)atof(buf);
7 }) T; Z. ^* K                Push(opnd,opn_in);
$ O# k, u. z& F5 Z& k                printf("opnd入栈:[%f]\n",opn_in.data);
. d5 z6 l6 r% q9 \2 U3 d1 O% C                i=0;/ u8 ~/ p  k" I& D0 W* ~( P
               memset(buf,0,sizeof(buf));& Y/ F6 V5 V/ U* u7 P" J& J' U5 W7 Z
         }* A8 \6 {& ^$ }1 G* G6 `
         opr_in.ch=c;* E$ V( s# G3 M0 L3 S
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
  k0 U' R% w5 o6 B1 ~, i          {
- X$ b1 [) B2 O             case '<': /*优先级小于栈顶结点,则运算符入栈*/) c9 p  d. W$ t, _4 [
                  Push(optr,opr_in);; }5 P. o  X- f2 {6 @. N
                  printf("optr入栈:[%c]\n",opr_in.ch);
6 d1 @- r" u$ `- B6 q6 e) u                   c=getchar();
4 v+ T3 B. W9 m: E                   break;
1 \+ L' C( ^; Q$ S2 @             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
2 Z, R. N$ q9 \* ~% y3 I% M4 y                   Pop(optr,e);
$ A3 e" B% `$ U. V# s  I                   printf("optr出栈:去掉括号\n");# B7 t# d6 V% W" ^
                  c=getchar();+ T2 h' S& I0 Q- k, W6 u9 ?
                  break;
/ C2 E2 b: Q3 s1 I             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
) c& H/ r) ~# r3 z7 }                   Pop(optr,opr_t);
8 \: p0 B3 T7 ]                   printf("optr出栈:[%c]\n",opr_t.ch);0 Q+ P2 Q. Z! I; B' A' j" ^' O7 u
                  if(Pop(opnd,b)<0)
: Z( b' W- ~. Y6 F                   {
6 ]* X+ B8 P: f- u2 @% x                      printf("Bad Input!\n");
- S" M$ f( K3 T0 k2 ~! L                      fflush(stdin);$ f$ W' h; j% x( o: ~
                     return -1;6 N/ b1 g! a1 w, G+ u
                  }
/ l7 W' Z# J: Z/ e! h$ C! C                   printf("opnd出栈:[%f]\n",b.data);
5 y. a6 k8 a. P! G- b                   if(Pop(opnd,a)<0)
' F8 Y" u6 U- `+ k: f5 h                   {/ e1 z3 o( @4 J! k; F' u
                     printf("Bad Input!\n");1 i8 ~& X; S5 ~% {1 X& f1 @8 x
                     fflush(stdin);: D, W- `2 s% X' r/ ?
                     return -1;0 }6 W$ Y- D/ f& X* _& T7 ?
                  }; I4 |% q& W4 M4 `5 n( A
                  printf("opnd出栈:[%f]\n",a.data);
2 ~% ~2 o7 t* U2 P. ]# K                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
- C' j4 M- ?" {# S. S                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/; B- R" t) S6 }$ `0 o- }
                  printf("结果入栈:[%f]\n",opn_tmp.data);
# l8 _& Y7 W. E  B- Q- |                   break;- a' q) }7 o) O! @3 p+ e; e
         }- ^+ i$ s1 |9 v0 z
      }
7 ~! J' n( w  p8 {0 H& _       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             , r/ |; E- U% `! p
}5 F7 \/ T$ z3 P3 C7 f6 h# [
GetTop(opnd,opn_tmp);
& `# d/ Z  ^# j; t DestroyStack(optr);
, i: A8 C9 k+ g+ T& ~ DestroyStack(opnd);
, p! e% I6 P% m/ Z8 ? return opn_tmp.data;
, P6 K% ~' L) d7 O* W- @}
, d3 s, X* b) {4 Y0 Y4 ]0 R8 |
% y# g* M# G0 g1 Nchar *killzero(char *res,float result)  m+ g- v. x" w: j2 H! |3 k% W
{
8 a" ?5 J1 z0 [ int i;# i% N& Q5 Z& g! P9 d# M
2 F8 w9 \0 w# V8 C* D, i! `- i2 G7 k
sprintf(res,"%f",result);3 K, K0 _' R# @6 Q/ z
i=(int)strlen(res)-1;, e& W8 @3 {& |  w% q& t
while(i&&res=='0')2 f$ J! ?& l2 L- Y* s2 m# w- l
{3 Z. R  D+ }4 y6 c9 Q
      res='\0';- o8 d- e% ~8 [/ k' P* [( g
      i--;$ c+ M4 x! F$ R. t7 w/ r+ M* H
}
1 n) Z; E& s7 x if(res=='.')- c# n) ], G: s# Q, S7 S$ _
      res='\0';2 @: _% \1 M: W% V
return res;; E0 h/ }! }) d1 @4 Y: v
}
% k# L: r- A4 a4 s7 M% |
, D1 t- g3 |& P' s, xint main()
! d- w: r  p" ?! n2 H' b' |! g{
% c. w: G, l/ \7 z char ch;
1 n4 H1 g5 L- D5 {5 Q1 R3 e char res[64];) j; s' O' S: N- ~8 X
float result;
: f6 @- w. K  w, ? while(1)
' D: T3 f1 V+ D5 i2 p7 Q5 |8 ^ {
6 s9 M, L0 w! y! Y- h; n       result=compute();1 k) e. h0 Z& @) K9 g
      printf("\nThe result is:%s\n",killzero(res,result));
! B9 f  L# }# A' U2 A       printf("Do you want to continue(y/n)?:") ;3 q; o4 b4 m- R
      ch=getch();3 p8 T; `8 D1 \6 h. a& O$ c
      putchar(ch);
* {9 q% }8 P; D! G6 I% S6 _. \       if(ch=='n'||ch=='N')
5 r' ?& c9 T( \+ A; M* A          break;# E( L9 `" [/ d1 u8 Y
      else
5 X* r$ d$ X& d! w+ Z0 p$ X          system("cls");
3 h" ^3 D5 |( S }$ q8 q) O4 c) _, ]
return 0;
1 z" q6 [' w& @}/ ~6 z, U" G% L0 u2 \# ~0 k1 l
* y( c( O- Q  }7 b# I9 \. ~. L
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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