C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.% ], z6 q; t% p( E/ W: W
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>3 e2 O% P0 t: \6 Y- p2 S/ M6 r
#include <stdlib.h>
#include <string.h>2 {4 v. c7 {$ N1 X
#include <conio.h>* Y) `/ c- m" l; }4 I0 G! E2 N
#include <malloc.h>; m5 Z% A; r0 R+ ~

#define STACK_SIZE 100$ b: o5 n' k4 R6 d4 R2 ?7 z
#define APPEND_SIZE 10

struct SNode{7 u, b- K$ j9 C+ x% G. ~- A" h
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};

struct Stack{
SNode *top;
SNode *base;
int size;
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/. Q/ z! C6 {' n' S
int DestroyStack(Stack &S); /*销毁栈*/+ O3 i+ ]8 a, S1 f4 D
int ClearStack(Stack &S); /*清空栈*/6 j7 `$ q# p& X. u9 I
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/( Z1 u  {, H# W- i0 j
int Push(Stack &S,SNode e); /*将结点e压入栈*/' S& c) t& v& k3 m
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
2 ?; R- R7 |) }4 x' N9 g$ z9 K  a( _
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/7 p1 K$ }8 ^$ g
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/" S! N" K* P2 G$ ]
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)$ x% V; a5 I& t9 i2 ~" m
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{, L4 K+ o$ i) [+ y; r8 C
      printf("动态分配内存失败!");4 G+ q4 k; u7 s# Z# t3 ^7 D9 U) u7 }
      return -1;
}# A2 s' h. O7 ~6 g" c0 b
S.top=S.base;+ M, o8 g5 z# n4 e4 ~1 L% ]& ?  Z- @
S.size=STACK_SIZE;& p. y9 {7 ~" a: y  Y  B! w
return 0;
}

int DestroyStack(Stack &S)2 B0 }% A7 U2 [) G8 d  s  |, Q) w
{
free(S.base);
return 0;+ [/ G4 p" Q. O( y) R! U9 `
}

int ClearStack(Stack &S)
{
S.top=S.base;
return 0;, K& P( \( d5 B# q6 A& o* Y
}

int GetTop(Stack S,SNode &e)
{3 f2 ~; U( N5 A' D2 p. p0 a
if(S.top==S.base)" u, i4 k9 u( u. V2 T" X4 u+ Z
{8 J4 \2 }+ O$ K+ W1 B4 I% h' y  |
      printf("栈以为空!");
      return -1;* n; |  v7 l7 G& R7 o
}% t$ ?9 d- C, a) b! t
e=*(S.top-1);! m7 ^3 u9 Q% b* i  ?* e6 r0 C( E+ i
return 0;
}* I7 K; R* c' v9 G! m. H2 ^3 ?

int Push(Stack &S,SNode e); S. y% `, K' S9 l5 j
{' v5 m7 A* F  [! b+ D5 @$ [& T: c" |# v
if(S.top-S.base>=S.size)+ O7 L- d9 Y- @. S$ h. e
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {9 A. B. {5 S( ?. S
         printf("动态分配内存失败!");
         return -1;
      }7 z; k- F$ X; j0 J
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;6 A5 a% m% `* [" ~  r" p7 Y( m
}
*S.top=e;  H9 I6 v9 q9 G1 U9 }4 q8 ]& b, v
S.top++;* e2 \4 R6 s% U6 x
return 0;: g9 |% m/ N$ i/ r
}
7 N* h2 k: }3 b" d+ m
int Pop(Stack &S,SNode &e)8 a. \6 h, T# m1 A  }' q
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);
S.top--;
return 0;
}

char get_precede(char s,char c)% n( P0 X3 \1 d1 i7 t5 g
{
switch(s)
{; G. e8 v) H6 [# h  d5 U
      case '+':                9 i% d$ p, y: e3 ]; V: f
      case '-':0 `) w( }+ t2 y9 q8 `( a, e
         if(c=='+'||c=='-')* t$ h9 J/ y4 V# }
               return '>';
         else if(c=='*'||c=='/')4 \. R+ g: n* z: n1 \# o  _
               return '<';6 o9 ?3 n1 L! h8 e1 o4 p, k
         else if(c=='(')
               return '<';5 s5 r8 `& v9 B1 B! u0 ^
         else if(c==')')$ [8 e. m7 @9 A. h& `9 V# l5 e
               return '>';" Y- v2 g1 X$ I- X5 i
         else
               return '>';9 L# U, c! a5 b: H" S3 C
      case '*':
      case '/':; K: ^( d* v2 {8 n, {5 |% ~* u0 c
         if(c=='+'||c=='-')6 K0 g" m3 j2 N' _/ N2 ]6 z
               return '>';1 v: K! X4 h$ g9 v/ k9 B
         else if(c=='*'||c=='/')" B- _0 r+ E* z; r
               return '>';
         else if(c=='(')7 T% y  C5 M* o1 h" x  h" d8 |
               return '<';! X8 G7 |, R. R+ a+ X
         else if(c==')')
               return '>';$ A2 g1 T9 Q$ O- `! k4 _- ^) w$ n
         else
               return '>';/ f6 x* M$ T" K- O& e
      case '(':) R0 D5 v  o* H, @# P" b. q- A% b2 Q
         if(c=='+'||c=='-')1 t: J3 F4 M7 K" B' W4 K
               return '<';8 O  W, S8 J8 l, B7 A$ f! ~
         else if(c=='*'||c=='/')2 f) a( O# [: q6 b* U* c
               return '<';3 i" _% u; h3 I
         else if(c=='(')+ U. s7 b. S- W! T2 {( o3 v* \
               return '<';
         else if(c==')')/ D% c+ i) B% d6 @& o) h
               return '=';3 v; U1 `( E- W! z
         else' n8 t6 b8 a& ~5 g4 h
               return 'E';
      case ')':, O7 n. i% s" X% d3 G7 v5 ?. A7 r
         if(c=='+'||c=='-')
               return '>';& J; ?' S2 m0 i! T
         else if(c=='*'||c=='/')# v: ]+ O" }9 r: {: E4 P
               return '>';# E. `: t- q( o7 T& Q1 m2 l
         else if(c=='(')
               return 'E';
         else if(c==')')( k( k% i; ~& x/ a3 [7 g+ j% |
               return '>';
         else, x6 Q3 t% O( ^+ q% J) ]! Y9 J& D
               return '>';% \. M5 `, I% k7 Y* a$ [! E
      case '#':
         if(c=='+'||c=='-'). I5 W) A6 T4 t# \) m! u4 |1 _2 `8 l
               return '<';; q/ V2 Y3 U- W
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return 'E';  Q* ^3 q( T8 p' e4 l) E2 l! `* \
         else7 X5 i* v( C4 W* H- g3 h2 e
               return '=';% M; k2 c2 T' h5 ?# N- c
      default:
         break;" {/ ]1 ~/ C, \0 u9 ~% O; S
}
return 0; ' E# g4 g$ l* B0 K% s. |
}- q( L2 j3 f/ @( B4 j) j& u
3 f/ |0 ]/ g+ ^4 T: H
int isOpr(char c)& j8 {: I- J6 t  ~( Y  K8 A
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;$ J- N. I  ~) k- O1 s
else
      return 1;
}) [0 G# ^- q! g  D

float operate(float x, char opr, float y)
{
float result;+ a+ F: X1 U+ F  t; G
switch (opr)) ~+ i4 U/ c6 l  R7 M, [6 c7 X
{
      case '+':
         result = x + y;! Q; P% \& q1 w% J8 g4 q
         break;2 j9 c( i! o/ ?" n1 }
      case '-': + |( d: b- T  K- l+ |) }( |
         result = x - y;% C: q9 k1 F& e8 l
         break;
      case '*':
         result = x * y;
         break;
      case '/': / G# S& B& k2 k$ [7 ?
         if (y == 0)" A9 E7 x7 E# X; x% T  V$ T
         {
            printf("Divided by zero!\n");* E. [* p# H3 l8 \: b7 p
            return 0;
         }
         else
         {" |$ {0 {5 E! A
               result = x / y;; R, H  q4 ^9 Y9 G8 w4 C
               break;
         }
   default: ( }0 j0 n! P& P; C3 u( G$ X* s" e3 u
         printf("Bad Input.\n"); ' ?. p  ^& u4 z+ S& R# k
         return 0;% I0 a% j" B/ z' v, p0 Z0 m  }; a0 s
}
return result;# _: |- F$ J( }6 }5 q$ _1 W' d, h
}
8 V& F0 G# A  n5 }
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{3 Y. T* n0 B; |0 R5 j, V
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;. t5 x- S' T3 f% r8 f# v
char c;7 |2 l6 L( N/ l) B0 t1 ^
char buf[16];+ D+ i4 R$ M" u& A( g; d! g
int i=0;
6 l, k8 D* p6 }% p) r* P! j6 E) D
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));! B  ?0 O- ~9 z2 _$ u; D
6 B. x- ^3 B% Y, K) q0 s: S. l3 T
printf("Enter your expression:");

opr_in.ch='#';; D! K5 @7 Z0 l7 D0 i1 H
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);9 `4 `* q* e; {' o- K
c=getchar();
while(c!='='||opr_top.ch!='#')
{# ]& S' P" W1 `5 {3 r5 ]+ h; J
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;, [, K6 }: t9 a' v2 R; x# @+ b
         i++;# y" @, o$ o; ^, c- `! t
         c=getchar();0 s2 o5 q# Q, O' @2 s
      }
) H! c5 e" `; P# a8 o       else /*是运算符*/
0 ^7 J6 ^! M+ `6 I) p       {
6 A' u6 P/ g0 ?( k          buf='\0';
* H: h5 h4 _, g) y          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
& ?9 b' X5 E: @8 V, E* e          {
# N9 {/ f/ Y5 N  t' o' |2 {                opn_in.data=(float)atof(buf);! {8 \. |# A" I4 N! c6 C) [# [
               Push(opnd,opn_in);
& c  W  D- A+ Z* ]  ~                printf("opnd入栈:[%f]\n",opn_in.data);! ?& Z$ [2 [6 R  J+ D
               i=0;$ U/ b; K' c6 F7 d/ l  o% {0 {
               memset(buf,0,sizeof(buf));
( |' S# O; d6 |% U6 h8 D, Z) U, \8 L          }4 a+ I9 N# _$ g- ^
         opr_in.ch=c;8 M8 W5 y7 O2 U2 O
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
, a) H# y9 o) s& s0 ]' j, M          {
$ Y9 n5 U& R) t2 i; e& ]* o/ M             case '<': /*优先级小于栈顶结点,则运算符入栈*/- [- ?: z' g4 W0 n* Y) Y- E$ }$ @
                  Push(optr,opr_in);
" g/ b& E. _$ i" p# t                   printf("optr入栈:[%c]\n",opr_in.ch);
. y* j. l6 N( |  M                   c=getchar();" T* m3 D( V" |: k' H
                  break;+ F4 t$ n3 @1 l1 ?' X) o: h' \
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/8 D& g0 ]" I5 f3 B
                  Pop(optr,e);
; o- g8 Z$ Z7 Y; F                   printf("optr出栈:去掉括号\n");
. L4 Y+ M. w% k1 w2 e) C                   c=getchar();# b" f: ^. b& ^
                  break;
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/) l$ M) I! t8 k# H
                  Pop(optr,opr_t);
4 p9 @- ^4 _1 o  i) r: z                   printf("optr出栈:[%c]\n",opr_t.ch);
- X' }8 P5 D6 E3 F8 `                   if(Pop(opnd,b)<0)
# b# z8 g! U4 t0 d% }; d                   {
  F$ u% ~* _, G' e# H* X# X; I! s: d                      printf("Bad Input!\n");# ?# b, K* n) N4 |& u: T
                     fflush(stdin);1 Z" \) ^7 X+ L0 q. |  P; X6 z8 w. C
                     return -1;
, w' \# |" v1 ?1 C8 X- E& y; B                   }
! b) ]- Q. {7 @" L% W: B                   printf("opnd出栈:[%f]\n",b.data);
" |9 B. O* R: h3 X2 i                   if(Pop(opnd,a)<0)5 c% \7 ]" S3 w0 u
                  {
; A3 S; f" y/ q& ^) W& j2 H                      printf("Bad Input!\n");
& S8 ^5 _! B7 R) i( g5 J                      fflush(stdin);- T- y  O1 I9 z) t* _
                     return -1;
, R( q& S- ?+ u5 \" ^) D5 P4 g                   }2 b! v( N" C# u9 s, i% S  b9 B
                  printf("opnd出栈:[%f]\n",a.data);# ?, O8 K  g& ?- C
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/" U8 g* X) o6 {( A! A" |5 {
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/9 |# ^( f# u* ]. \& [- q
                  printf("结果入栈:[%f]\n",opn_tmp.data);* _* D3 b. H0 Q6 L" I- F
                  break;) z6 z2 ?' l3 g: D* p# y
         }% k8 z1 o# U9 y# e
      }
' q5 C9 G" u5 t3 s, z" f       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             / P! R  |9 I# t) M* y
}* k0 P/ k7 ?. c: n8 B, q- L
GetTop(opnd,opn_tmp);8 ?3 @, f( e! t* x8 K" a8 y
DestroyStack(optr);
8 r, o* j; A0 \2 N' A% y DestroyStack(opnd);
% r2 D" N- B3 N9 V9 w return opn_tmp.data;
2 ~" [8 F; \7 v1 K* W8 D2 i4 ^}
" U8 i' b' Q* K: m2 L
: J' ^* U( s! B6 echar *killzero(char *res,float result)
; K9 F: g& o5 N) E{+ K$ P  L( C$ A6 c
int i;: d, q% m& R/ M7 a. \# g
1 F$ `$ k# i# a
sprintf(res,"%f",result);% P6 B( Y0 ]) Q) g
i=(int)strlen(res)-1;
" s9 `7 i( u7 G2 k+ ]* v while(i&&res=='0')
" ^% l; z; T- L  K% v5 D, S {; L  }( i# Q9 k- Z! L( r$ z$ @
      res='\0';
, o0 \! v) V+ f2 [       i--;) ?7 F8 C: o& I! ]2 @4 E9 b6 q
}$ \  G4 `' g+ `* A8 g$ D9 ]
if(res=='.')
2 Y* B  v# q5 ^       res='\0';) f8 w* E; r6 [: p- q% J
return res;
$ G9 i9 w3 z) S- u* k+ j$ o}
* E- }  @; h# s% D: }% b0 O: y+ r: X/ D4 w8 J
int main()
2 B% [4 \. e1 ^1 Q8 a5 ]! l' a{
2 e0 m9 X5 [2 u5 J* W- E( q5 T char ch;' F! [0 ]& F8 I4 d: r
char res[64];
) s- M4 Y5 u8 p* g float result;$ S5 g$ D6 o, v0 T2 ?
while(1)4 H3 M1 r) X2 r# W( k
{
) u; g  m3 s( r6 q2 v$ |6 r9 W       result=compute();2 I* g2 s3 M' r8 T
      printf("\nThe result is:%s\n",killzero(res,result));
# ?6 S, \- M3 a1 @' |# B  J4 D       printf("Do you want to continue(y/n)?:") ;' Z8 _- L) o. G3 {1 Z" G2 z
      ch=getch();
* Y" o6 O3 |5 n* s3 r       putchar(ch);
/ W5 ?$ g# i5 b* U! @       if(ch=='n'||ch=='N')
, U% W- k, n: [/ r8 h          break;$ u  Y# r' \7 r! I$ A$ p
      else- {. G" h$ U! O3 |* F
         system("cls");5 z' F' [9 q$ E& ^6 W  y
}& o& B) P8 y5 Z) y
return 0;
/ @3 x' ^$ C* q1 k9 n/ L$ K3 ]' `}% N0 }7 ?/ ~' u* P( q& H
1 [4 G4 ~' H$ Q
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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