C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.# i7 B7 h$ {' `' E
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=0 K3 g" [4 J6 J; V7 W0 Y5 q0 J
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>- C3 z2 p! j. F, M
#include <string.h>
#include <conio.h>
#include <malloc.h>1 T0 t( \' K. C5 M6 K# r

#define STACK_SIZE 1000 b0 ]1 k' `+ c3 U% c
#define APPEND_SIZE 10# p  t9 t$ ^# N6 V/ H' \% ~: Z3 j

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/- U: g5 g; Z& C: O( i: k
};

struct Stack{
SNode *top;4 c# E7 l3 K0 |/ K6 G. O
SNode *base;
int size;9 U8 Y9 B7 {. t$ T8 A# t! ]5 H
};, g! ~  n) O( ]0 c. P

/*栈操作函数*/3 k% B- m9 |/ s' {
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/4 {& a! J. s+ ]8 h0 L+ B9 O2 x
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/! L' L4 K* k$ y7 u' @7 E9 s
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*/ 6 n, G9 k$ [0 p+ r

int InitStack(Stack &S)0 i, q3 B5 R3 H! p; j  z. s
{" g* a! Y8 q* A3 L. j! z* r
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));, @6 H/ M% X) l. N# w" G# [
if(S.base==NULL), i4 n8 M* t& t
{/ h& {' T; P- L
      printf("动态分配内存失败!");' g% N- F) u0 M* q- g8 V# b0 B
      return -1;5 {8 m4 }- |% o9 O; S2 I
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;8 v" G' h$ B1 R) j( \
}. V6 R  g, v1 @9 p2 O% x

int DestroyStack(Stack &S)
{
free(S.base);/ J  c) O6 l- N
return 0;0 c1 O; a: a# d; l9 D6 u7 @: I) m
}  h. F: K4 ?# _: m! d$ J

int ClearStack(Stack &S)
{  a, S; P) C  [# Z, y
S.top=S.base;8 e* e( C8 T8 F' |, M$ I1 H
return 0;
}$ Z2 u8 x% ]  M% Z+ `/ v
& @) o4 b$ c4 s
int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)! X. L- m; |, S3 l
{
      printf("栈以为空!");
      return -1;
}( E& m% R. Y6 |# o/ i" S
e=*(S.top-1);
return 0;
}
9 Q& p% v0 h; ^, q. w
int Push(Stack &S,SNode e)
{8 {- a) C+ [5 ~+ |
if(S.top-S.base>=S.size)
{! j9 N- G0 u: M0 `# `5 ], P
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)+ ]. y; u( u# G" B4 `
      {
         printf("动态分配内存失败!");' i2 `( C. O6 N: ~' M
         return -1;7 E$ a( R7 G4 |4 }% L/ u0 g
      }
      S.top=S.base+S.size;; v" t! ?# i6 S' e* D( O
      S.size+=APPEND_SIZE;) J4 p5 q( Y4 M
}& O, m& L) P, e! Q" M  V" J0 S4 q2 }
*S.top=e;/ {  x' h4 T% M0 x/ L
S.top++;; J0 g$ W. Z" E4 Z! V! C
return 0;
}

int Pop(Stack &S,SNode &e)
{" v; {- K; p( Q2 T/ O4 |
if(S.top==S.base)
{
      printf("栈为空!");# r( a2 a* ~& ]+ \
      return -1;  r0 c2 \7 K* ?7 @1 q
}; K1 W3 D: A& v; X7 y' D7 U% J( i
e=*(S.top-1);
S.top--;
return 0;) {0 ]! n/ u1 t2 N
}

char get_precede(char s,char c)
{
switch(s)
{
      case '+':
      case '-':" W1 U  W6 X  M! S+ P
         if(c=='+'||c=='-')  l/ B# ?# K( r% a2 i
               return '>';
         else if(c=='*'||c=='/')/ a1 }" R0 ?3 \' Z
               return '<';3 b/ ?6 p" }1 g3 F
         else if(c=='(')
               return '<';
         else if(c==')')5 u" t: R7 j! q# D# v8 \1 S" |
               return '>';6 X4 U3 O9 C9 B4 a2 i
         else 8 t' C  i/ f2 v( |4 R7 U- H
               return '>';
      case '*':3 y0 p$ T/ h$ U+ Y1 l
      case '/':. f2 I, s, M- D3 Y
         if(c=='+'||c=='-')( w9 ~5 ]& L: ]1 U6 _
               return '>';6 |  G5 E/ s3 ^" F" h4 n2 q4 Q5 W
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')7 v0 @  x5 O; w# B" ?9 ^3 C' ^
               return '<';
         else if(c==')')% J- h- I" r- n4 |" Q
               return '>';8 D+ i: ?8 L6 L* d2 Y4 v9 w9 @
         else; Z6 S- ^6 C+ C. H; |# |: m
               return '>';+ ]: a9 |9 @  t( i) X; Y  A1 M
      case '(':6 h4 v, [9 S9 s/ ]* d
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')( l0 e! Q9 r5 y  _
               return '<';- e5 t4 v9 @, e. A4 l; v/ V3 ~0 y
         else if(c=='(')
               return '<';1 ]$ A9 ]7 Z: `
         else if(c==')')- @. X: H: w+ K  w
               return '=';
         else; A" `2 n# D, @8 R) U. @5 m) b
               return 'E';2 D* K8 T0 z8 s* w& G( Q0 c# T
      case ')':
         if(c=='+'||c=='-')5 [. h7 s0 H* ~; H, A6 V
               return '>';' ^$ J' Y, u0 i* N
         else if(c=='*'||c=='/')9 q' e1 f" e4 V' v% H
               return '>';& c. q( G/ U5 |: G
         else if(c=='(')
               return 'E';
         else if(c==')'). d7 i) B! E5 P5 h4 e( g$ W
               return '>';
         else- h  V) S: @0 o, V% i+ }/ f' i5 O
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')" t3 \; v) Z+ n7 [0 A
               return '<';
         else if(c=='(')1 B( F) a/ \- ?4 I
               return '<';
         else if(c==')')
               return 'E';
         else
               return '=';
      default:
         break;
}5 v5 u0 S# S: J3 {" f  x
return 0;
}. D7 d0 Y! |& V

int isOpr(char c)+ q$ i1 I! W7 s( |3 u
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;7 V4 r3 e) V) f- M0 ^# P( x
else
      return 1;
}2 r3 \  e: y' a/ o( m) u

float operate(float x, char opr, float y)
{
float result;6 n* w7 S7 m9 m5 K; b% h1 ^" }
switch (opr)9 E: T. Y5 J' l+ v3 x
{
      case '+':
         result = x + y;: y% l/ _; a9 U1 [1 D* \- O7 K
         break;
      case '-':
         result = x - y;, x  Z  R' z2 I( K, O6 N1 v
         break;
      case '*':
         result = x * y;
         break;& |8 J( N" E" P9 |
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;, B6 l1 h0 a) E9 U
         }
         else# [& {$ E7 k/ a. I1 j0 t
         {! y2 c8 Q; B7 [/ g' o
               result = x / y;
               break;% t- W8 t- I, T% }: \. Z  t4 x
         }$ Q/ m$ z& G- ?& {6 b3 ]/ K
   default:
         printf("Bad Input.\n"); 3 c- g2 l& \( I( o# A& W6 h
         return 0;
}
return result;2 v. E2 w; o: T! S# d1 L7 w
} 8 |# D5 ], Q( r1 Y# ^; n
8 e# F: h9 v) o/ N6 T
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/, x5 d% z! W$ o: ]
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;- T. p" _6 J" t  ^* h( \- e
char c;( p+ ^) d8 a. f
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/1 B, _" o  z! F
InitStack(opnd); /*用于寄存操作数和计算结果*/9 \( _0 w6 c( b7 O+ K) Y
memset(buf,0,sizeof(buf));
1 `; @# d1 V2 g$ \
printf("Enter your expression:");+ p0 n# y" W6 i* N. T; Z' A

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);0 P, l  M/ l. g; g) H
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
2 l" c) @2 D7 f; {" R5 d          i++;
8 }4 g+ `) X% i3 v: o          c=getchar();
& K4 l: t' C0 D) e( j       }  j. H; t+ a3 P& c
      else /*是运算符*/
+ B9 x" \7 e# X       {
8 i2 Y' u5 ?% U3 f$ \- U3 D& I          buf='\0';! q9 U1 M+ t" u1 n5 J% _1 P' F7 K0 ^
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
8 d: _% `) z5 I5 R          {0 C" D9 t; A+ o7 O. ~6 g( P& M# x+ z3 t
               opn_in.data=(float)atof(buf);7 S4 j/ Z& X8 v* |; P% X& {
               Push(opnd,opn_in);
! v. h' C* {! m# N                printf("opnd入栈:[%f]\n",opn_in.data);  G5 J# K! `+ t% R4 y  t1 Z* Z0 P
               i=0;
4 q9 J; {" }/ Y3 [                memset(buf,0,sizeof(buf));
3 O* Y/ V. t9 p$ w2 J/ o          }6 h. b2 M) t0 K* J6 O
         opr_in.ch=c;- X9 _0 A, _6 y( X8 E+ I/ s7 Z/ h$ d
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*// N: ]" p' h& o8 T: l+ }# f
         {( F5 x( l2 Y( X3 @
            case '<': /*优先级小于栈顶结点,则运算符入栈*/* f% k( |: q+ s/ Q/ `! U
                  Push(optr,opr_in);
: B' C4 _7 D5 }# I                   printf("optr入栈:[%c]\n",opr_in.ch);4 U# _# r' k3 }0 _3 u
                  c=getchar();
$ l+ a6 P* n8 }) A* T- C; }0 y                   break;
& p& ]4 v) l. x# c7 v             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
4 O5 t; w8 a  z5 Z1 l+ Y" {: U7 {                   Pop(optr,e);2 _8 I2 C6 T% [7 p6 h( t" E
                  printf("optr出栈:去掉括号\n");$ n& X$ {* T1 D/ \
                  c=getchar();
# l9 ~+ z& X- o( v8 r/ b                   break;$ O) O7 x/ p/ X* N( J
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
3 H4 G# s7 [1 i9 y6 |  l                   Pop(optr,opr_t);
/ T) K4 O; |9 j5 i3 ~9 M                   printf("optr出栈:[%c]\n",opr_t.ch);
1 ]- E$ S! R2 D: U3 s' d& M                   if(Pop(opnd,b)<0)
6 J& v) r) e( M' r                   {, F! h  S1 V; Y$ ?/ f
                     printf("Bad Input!\n");. R% U  q5 @# z0 S8 n% E
                     fflush(stdin);
# R+ c. l6 k$ ?# O2 o8 l/ v9 L2 h                      return -1;
6 F. Q5 |- s) _+ C& f& I  z                   }
" H% ^! P# ?' u  v8 C8 _* e                   printf("opnd出栈:[%f]\n",b.data);
5 l8 s; N) v% L- A7 ?& t/ R. a& e                   if(Pop(opnd,a)<0)
/ \' Q* h' a. o9 A3 h                   {
1 e% J8 p! X# e- I) h                      printf("Bad Input!\n");
; R& R; i7 p3 _& M) ^                      fflush(stdin);
( M, M0 w& K* Y0 ^7 }                      return -1;
* A9 `: s) O: e9 p) K5 M                   }
8 j5 c- i3 ~) w) B3 e8 I                   printf("opnd出栈:[%f]\n",a.data);9 n4 L% C8 m" c2 b
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/& f7 ]$ ~& A7 D' [* |9 v$ R# z
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
- [6 J5 j# B' X# ^9 H3 k                   printf("结果入栈:[%f]\n",opn_tmp.data);3 _- S7 P. E1 c8 _8 ]3 s( N7 Z
                  break;
  Q; O% d6 x7 h0 C          }% W/ q8 G, C9 J8 a
      }
) @- \4 |3 @+ c, Y       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
, L+ C9 O: R# N: Z; q7 C }% y3 i3 ~. F* n' o
GetTop(opnd,opn_tmp);
# k: a1 T$ d( z+ X) U DestroyStack(optr);
# y0 o' _- m, P7 o DestroyStack(opnd);
8 }; j! e2 L, e8 Q5 i4 A return opn_tmp.data;, u- x6 l# G. K3 I
}2 u- b8 h% q0 v2 U

0 D+ j( E( C+ T0 ^  U5 ichar *killzero(char *res,float result)" j+ ?+ r7 q' t) h- q+ F6 B
{+ U& D2 |* l  F
int i;& g6 k- N+ {( W) R: x8 X+ }
/ a/ f- E% i) k
sprintf(res,"%f",result);+ l' a: J( ^! k% a, J" Y7 B
i=(int)strlen(res)-1;& k7 x. ?& W0 _+ o; @8 w2 E; }" t
while(i&&res=='0')
; |9 E5 y0 T+ R7 |& H2 q {
6 ^7 K$ a; t1 T9 U       res='\0';4 g( L( h3 i+ J- U7 ]1 h0 o9 t
      i--;4 |' D+ |# j5 J. k8 M
}
3 z" x) q  B- Q7 s# N9 {' d( E2 f if(res=='.')
+ @, f) C3 h$ D! W: C( F# z       res='\0';0 b; u2 A& r" n1 K4 D5 D8 s4 c4 o
return res;
3 _* O, s% p+ u4 F}% R; b) L5 g" X3 q! [& {
; g2 w2 x; P; F5 K+ s+ V6 f
int main()
" E. j6 r4 U7 _{8 X2 a/ Q3 K6 e0 w* v( a! B
char ch;
* }5 Y# F+ K, r char res[64];  f& f- ^6 e+ w: w! W# x% ?) e
float result;9 ]3 P) A; g" [2 S, v- [# G. b: d# x
while(1)- o  \' O$ d& i2 n6 U" @
{
# Z) v8 d6 D7 R% p       result=compute();  b6 Y( G8 z8 ~/ I  |
      printf("\nThe result is:%s\n",killzero(res,result));
; a/ h# ^0 M2 V' Q6 [# j       printf("Do you want to continue(y/n)?:") ;, P# X  o) j. S5 d( _+ s9 Y- w: Q
      ch=getch();$ `3 y& g9 V6 E: r' Q
      putchar(ch);
+ [: S+ l" U; P: p6 }. l       if(ch=='n'||ch=='N')2 }& g% f: U4 M* \% i
         break;) B! q/ y! I" \: n1 O7 k
      else
: t- Z: X1 x8 Z! i0 y5 G          system("cls");8 g! n1 k( f5 f8 d
}8 \; |) q: Z0 F) L, ~1 ^
return 0;/ Y3 Z! e/ t7 `+ `8 P* n4 O6 K
}
# M/ |+ j1 _' l& e+ v
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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