C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>8 F. t8 P; k& Z' C
#include <string.h>
#include <conio.h>  f) a. C) i1 R: i
#include <malloc.h>
$ @5 w: e. M. @
#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{9 Z" v: |/ s+ P
float data; /*存放操作数或者计算结果*/7 p, M9 p9 o* K  |6 W
char ch; /*存放运算符*/
};
- @* n0 ]3 S! r" }0 r) O0 h1 ]4 F
struct Stack{5 y" c" C; U! K
SNode *top;! |6 j. r8 c6 }
SNode *base;; u6 x( g+ R, T! p
int size;$ W4 w" w2 f9 X' w9 \
};6 p" C1 l0 p1 V# N

/*栈操作函数*/) n- d9 L/ X2 t- {0 }# E  W7 Q5 Q  q
int InitStack(Stack &S); /*创建栈*/, \0 n) `2 D1 o, J/ {
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/" \" a% J/ `( l% I# L
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/5 R7 g' E% L, B* C  l5 E
& O" E2 v/ a  P0 T
/*表达式计算器相关函数*/  E2 ^0 y9 ]7 w% r% d, z1 G+ ]
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*/
: x& Y% Y6 O9 N' }
int InitStack(Stack &S), U- R# J4 R1 J5 d/ @# E0 J9 g/ q
{! B0 e6 f+ _7 k5 e1 E3 b& W4 Q
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));& R5 c: }6 V! [- }
if(S.base==NULL)$ _& K: ^+ E, C- J
{! I0 Y0 w, t, A9 Y3 ^2 h/ b4 x* l2 X
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;. M& \. k  M6 t( `
S.size=STACK_SIZE;
return 0;
}
+ c/ |: `0 m4 `6 z9 D) Y
int DestroyStack(Stack &S)
{. z: _& N0 ^$ c2 F" j7 M
free(S.base);2 z1 U5 N+ V( s$ i8 N* e
return 0;
}

int ClearStack(Stack &S)$ x  ^9 P8 j& q, U1 ?) G- s- G4 G
{
S.top=S.base;
return 0;
}  T/ B  @$ M. z) x8 d; T& g: h

int GetTop(Stack S,SNode &e)
{# C/ V0 B# W8 h! w; ]
if(S.top==S.base)
{& ?2 E5 P  w& d2 E* y
      printf("栈以为空!");, U. x9 N$ ^+ l" W+ b: r
      return -1;
}
e=*(S.top-1);
return 0;% u( }. ^5 z+ v8 B$ S
}

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));
      if(S.base==NULL)9 G' Z/ z5 W& r* `" e/ ^1 Z
      {3 r0 _# y: O# E9 V5 o
         printf("动态分配内存失败!");+ [* P" P# Q. t9 F% l) j$ v
         return -1;
      }
      S.top=S.base+S.size;# y" R0 A! T  Z) ]  |) d
      S.size+=APPEND_SIZE;9 j4 E9 h/ y6 ~5 M
}
*S.top=e;" h) o. S4 y4 l$ |1 S1 Z* \
S.top++;# W  e& j4 T+ \+ W
return 0;5 H; s3 V: j8 G. r+ L( A* F$ s
}* l* \0 J+ c1 r4 K
9 p" b+ X* N2 y4 t' [$ G
int Pop(Stack &S,SNode &e)$ m! }$ x% w6 _
{4 L% M# j! d0 a+ q0 X- z5 g/ r. c
if(S.top==S.base)
{% r+ O. c3 m9 G8 o# \
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);
S.top--;
return 0;
}0 a' G! ]3 g+ C
2 d+ @+ L$ R- N) H2 d) _: [& k
char get_precede(char s,char c)
{
switch(s)% `  i" F7 h. Z% A1 N  }
{
      case '+':                # o2 D, T/ h2 \- p) F# T
      case '-':& c  R+ S5 u' i6 n) C
         if(c=='+'||c=='-')9 J& s: i! m! z4 B
               return '>';# a9 E# F: }; J. b$ x
         else if(c=='*'||c=='/')+ A, S7 k5 k( H3 s- M, `
               return '<';: m- T$ S* {0 k
         else if(c=='(')  ?4 d+ L3 r- C0 K" R5 U4 b
               return '<';
         else if(c==')')
               return '>';
         else ! @/ X7 I( }: a% k8 w/ R
               return '>';9 g' \0 Y, K* L9 O
      case '*':7 N- R8 G$ T8 O$ b" ]
      case '/':+ D. F1 ~6 }/ R7 u8 Q7 t; N8 c- W
         if(c=='+'||c=='-')/ |9 f$ ~* L" A$ V! K
               return '>';
         else if(c=='*'||c=='/')6 @* B  T: X& |" t2 e) z6 {
               return '>';5 A* @; V/ e8 V6 ~& A: ~" t
         else if(c=='(')
               return '<';/ K9 C' z$ G' D5 t
         else if(c==')')7 X) ~7 K4 S' k) }) Z; [
               return '>';# n) E$ \8 m$ x- W4 s2 }
         else
               return '>';" i' Y+ F( O- y1 e
      case '(':8 D. N% A& Y, z: e. F9 Z
         if(c=='+'||c=='-')0 Q: k. i; q8 o' d  x5 h/ n
               return '<';% B; p; q1 V$ E0 V3 n+ O8 p
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='('); N: G$ ~, N5 a! T
               return '<';
         else if(c==')')
               return '=';
         else
               return 'E';
      case ')':$ s' P$ @7 p+ B! H7 I! u
         if(c=='+'||c=='-')
               return '>';- u, l  ~! ~1 Q& P
         else if(c=='*'||c=='/')
               return '>';4 n3 V% u6 L6 Q: L- N+ A
         else if(c=='(')
               return 'E';
         else if(c==')')) y/ R, n! y, v! f0 L
               return '>';3 b' h  C: h' }" Y
         else- t' g1 F  e% E2 b/ Y% ~
               return '>';
      case '#':
         if(c=='+'||c=='-')4 j$ t$ a3 F1 i/ C# ]) Z9 O
               return '<';( N# `4 U6 Q5 K: {% F* F) _
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')' P- H% B. V* ^/ k6 Z
               return '<';
         else if(c==')')$ P. f6 u7 E0 _. O, n& R
               return 'E';; R( a0 R2 N8 J4 i5 a
         else# i; s& }- O* T4 a8 e/ O, S
               return '=';  b: |, R2 |% i; j- j3 k! h
      default:9 y) w) \" u- N! d9 `
         break;
}+ A7 H0 x+ _( X% h, L9 G5 X( F
return 0; & Z9 s6 [  s! T& ?! A7 \
}5 R9 L2 [( [8 z- L$ [

int isOpr(char c)9 F( X8 \9 h4 }$ X- H: L3 Z% u
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')7 v' {6 X' p3 U, P. u8 h, q( h
      return 0;
else
      return 1;
}

float operate(float x, char opr, float y)
{8 {# d+ Y$ S6 ?& Y
float result;
switch (opr)  B0 T  \" k& B
{$ @( K- w; u7 f, q" o) S4 U1 K
      case '+':
         result = x + y;2 a; z5 g4 S8 \/ J, u: }" N6 A; w
         break;
      case '-':
         result = x - y;
         break;
      case '*':
         result = x * y;
         break;
      case '/': " B6 x3 q! l. d1 N
         if (y == 0)6 @* R4 [9 l5 O( t
         {
            printf("Divided by zero!\n");
            return 0;; M) J& u  ]9 s
         }
         else
         {- [/ ~5 P- c0 u+ c
               result = x / y;7 ~- }+ L  ^5 Y7 C
               break;
         }
   default: - _# K& w7 s, w" ?2 ^+ E
         printf("Bad Input.\n"); & ]0 Y0 M3 ?; f. p; D
         return 0;
}
return result;, P& C6 p& e/ M  {* |0 |9 @6 n
} 8 [/ r' k! c1 u  `$ |+ l0 |

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/2 {* _: p: X: s* B
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;: Q2 w% Y& B4 t% J
char c;0 k; \) z* A) H* u( m- U& T
char buf[16];
int i=0;# \! K' z* \& d6 v' E# [2 ]* I

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/  B$ Q5 C% I4 T" }) e: U2 j5 B! L; n
memset(buf,0,sizeof(buf));+ _( b; ^4 L9 j! Q
6 Z- S' e: O" u6 W3 ^
printf("Enter your expression:");! J( ], m, v+ Y

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/8 y) W$ D! R" H; H
GetTop(optr,opr_top);' H& G2 Q: n- L
c=getchar();, h$ i# ^4 l0 b( U
while(c!='='||opr_top.ch!='#')4 [$ ?+ {& H" C4 T! B
{$ B0 b( x  P3 R  j2 E" `
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/" m0 |2 D3 j$ d" R4 w) T
      {+ o2 E( V. l5 ]4 c, U9 j2 c
         buf=c;$ |! G- s- q8 a! ?7 B" {& e- j
         i++;! F& Q8 f. O. E$ F' ~/ i
         c=getchar();( f- V) N  t6 X7 L
      }
4 U0 e$ Q" C2 F! w3 C9 Y6 n       else /*是运算符*/
; ]0 S" f! E$ v- U' `       {& @! Y, h/ H/ J, Q
         buf='\0';
5 J3 x7 N- w6 l. t7 W          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
. r# v% \8 I8 T2 x9 ]          {
/ \. [: k3 B2 x$ ^. Y8 R. R                opn_in.data=(float)atof(buf);
( M7 \) I: G1 e                Push(opnd,opn_in);
& U3 R) q. a: i( A4 X/ W                printf("opnd入栈:[%f]\n",opn_in.data);, M" Y3 Z  U5 |# {
               i=0;
# w+ k1 |" I, M5 y! G% ?                memset(buf,0,sizeof(buf));
2 B4 }; ^- F+ y) r$ C% X          }
9 ^& ~5 k5 L) L" N          opr_in.ch=c;" r  ~( u  h1 l0 I. @
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
2 Q: l4 f3 W: L& f          {+ c% T/ J  K7 m* `" e) Q
            case '<': /*优先级小于栈顶结点,则运算符入栈*/) e4 R7 |: l; V6 b9 ^  v
                  Push(optr,opr_in);  d% D% f0 I' r
                  printf("optr入栈:[%c]\n",opr_in.ch);% W$ D5 j/ Q$ t
                  c=getchar();
5 s( C; X$ g( A* A                   break;- U/ _7 j. f& s5 x
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
; A9 M- L% `+ U, Y! I  U7 V                   Pop(optr,e);
) {5 y  |0 j8 j2 g                   printf("optr出栈:去掉括号\n");# p4 n' D$ s- `6 t
                  c=getchar();- t' @1 [( n1 U( k3 n) w( W8 ^
                  break;
) G3 i% J, [( i2 v7 W             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
: ~( e, c6 R# ~* z/ T2 z5 f                   Pop(optr,opr_t);
8 Y6 P) a9 R; K( Y: C                   printf("optr出栈:[%c]\n",opr_t.ch);3 U: p  r3 X7 ?% o3 X0 ^+ }
                  if(Pop(opnd,b)<0)  y9 q5 j& f0 M7 q
                  {6 j; I5 J- i- _5 S, l2 L! G8 q
                     printf("Bad Input!\n");! R+ ~$ r+ ^4 E8 i0 d6 r( u
                     fflush(stdin);; B  w7 c! t5 C% V$ `
                     return -1;* R7 [; t! v4 e9 H* L
                  }2 O& Z! U. b+ K% n: _4 q/ n
                  printf("opnd出栈:[%f]\n",b.data);; N9 ?$ c2 j; F% p
                  if(Pop(opnd,a)<0)
8 s9 a6 m2 f6 ~                   {2 Q' c3 H) M3 `( }$ T! T6 K
                     printf("Bad Input!\n");
/ Z% Y: O! d4 @, x                      fflush(stdin);
( F% o" r% F" F& K9 u- A                      return -1;
# N. z% A/ S" l                   }6 v4 ?6 w# a: d3 B
                  printf("opnd出栈:[%f]\n",a.data);
( _. V! C+ c1 l3 H8 Y9 r                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/7 X- L* V8 e/ k8 z" o
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/( o  J7 I& [  B
                  printf("结果入栈:[%f]\n",opn_tmp.data);
+ S( E& r9 `1 |6 n/ Z* H0 Y( z                   break;
; X( ?& L$ U& I) v1 o          }
' s, V" h8 j. L       }
) H& {1 z) n2 ]4 ~% l* l* D7 z       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             + \8 A: Z- V4 Y& a7 I4 O$ f
}: t9 s+ M! H( J9 c
GetTop(opnd,opn_tmp);3 r3 e" v& U+ Z
DestroyStack(optr);0 ~/ x2 E0 G8 O3 v0 O
DestroyStack(opnd);
- o/ \0 V2 a$ P+ I' T return opn_tmp.data;
( k" l$ z' a% e% L" E) `% n* @}8 T& O& J; ]4 }" b( P
$ [7 t& Q; C- Z6 w
char *killzero(char *res,float result)
4 ^# M2 p! R& Y( f{
$ ~# v- ?' }$ _) T% l int i;
; R. I" L" M  f8 i) h8 [. o5 C8 L, O
sprintf(res,"%f",result);. a; m* X' i2 Z! g, I# O
i=(int)strlen(res)-1;
+ D7 ^* ~0 ~$ f" c" q* B! O0 F1 t while(i&&res=='0')8 }0 V- o8 i. e
{- I9 m0 G. V& X$ b2 x
      res='\0';
9 Y! p) k' I& m       i--;
6 Y3 ?+ k5 S  p& g8 ` }! u; F+ l; `/ l+ u
if(res=='.')
3 T' K$ L& q  i* U. f4 K8 V# F       res='\0';$ N5 z# _7 c1 u" H" E
return res;$ G# Q  c/ a0 E: E$ O6 b2 p) ~; j
}
& c7 [8 V# A+ Z5 h( E1 j  ?1 @7 r' q! ], M! k. ^% `+ ?. Y
int main()# \8 N- N% I) `, O
{
! f7 f4 b8 e4 }) K char ch;
# W0 G  M: Y( ~. c  n7 J char res[64];
2 X0 y8 C" f3 a0 B float result;
8 A) \7 }8 y' V5 R: i& s$ ~ while(1)3 X2 A2 K; O7 a5 E5 f; \0 n
{+ @& P8 R/ y" E5 a0 j8 V" f
      result=compute();0 W9 ^8 p, O( i
      printf("\nThe result is:%s\n",killzero(res,result));
# l! Z9 h/ j% _9 I1 T. y1 B+ j( K       printf("Do you want to continue(y/n)?:") ;# l+ y2 e+ [* H$ s" W
      ch=getch();
. C; ^* V) k; @+ m1 i       putchar(ch);
0 y% E/ _! F9 B* Z& f) O( @1 u       if(ch=='n'||ch=='N')
4 w% e# [6 t& ]. M# ?( Z          break;
1 Z8 i1 G; p8 J) ^5 J) [       else
. Q' I2 e4 ~: c          system("cls");: g/ z: @: C& r, |* |8 V
}. q3 R! h; p7 n/ D- T" H1 Q, f  ?
return 0;0 q/ u* U1 b$ k: z+ u
}& ~: o) x; `3 s) a& X) V! A5 J
7 p. o% b$ J7 a, [$ [* k
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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