C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/% U5 B) f8 V1 V5 O5 Z  L0 c
#include <stdio.h>
#include <stdlib.h>: L8 D3 O7 Y5 G7 u( x& U7 y* l
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/9 F# Z' a5 E4 C4 l. S- m
char ch; /*存放运算符*/
};
4 m0 o  T$ ~8 n7 J- N: X
struct Stack{' n) G  u- I  s5 R+ I3 p
SNode *top;' C. P2 v8 D& y% z$ u. \" v, x
SNode *base;
int size;
};% K) p4 l7 A7 v( W/ n" O( ~
" y, ~4 Q) F' \7 Y3 |4 k9 j
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/( Y' j% Z" T! L& }6 b) d5 I/ @; I
int Push(Stack &S,SNode e); /*将结点e压入栈*/2 i* C9 F% k. y! J8 J3 Q) p
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
: j! @3 h6 X5 Y8 I9 l0 q  s1 z: ~
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/( X" p, h, z7 C' Y& ~: ^$ N
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/8 y% L8 m" G: J. Y) f0 j1 T- p  k3 }
char *killzero(float result); /*去掉结果后面的0*/
$ ?. T3 |6 c# t% i" R- A
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;$ t1 J, J6 b  J# Z; n
}
S.top=S.base;8 Z3 Q6 F5 V0 w. x! \; [: y, z
S.size=STACK_SIZE;
return 0;! ~; e) R: i  y
}: ]3 U2 x3 g& o

int DestroyStack(Stack &S)$ H6 x0 \% Z3 m5 Z0 s6 |
{
free(S.base);1 d: [' X+ O  k  u
return 0;
}5 H" R  B% o; X3 b& i2 T8 q
/ k! K0 m: d9 `7 G* G" K
int ClearStack(Stack &S)5 W8 ?/ S3 }) @- _
{
S.top=S.base;; b; |; U1 i3 t: d: z
return 0;5 L- F$ J/ v  Z# j( E& N! V. O
}8 ^5 ^4 ^. a0 Y* Y6 R

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)* K% P; ~6 _' z
{
      printf("栈以为空!");
      return -1;, x& B3 T; S3 d6 z7 O# A
}, b: y% x) u4 b$ e% k
e=*(S.top-1);* E$ }! S( _; T8 o% B7 v; G" j1 ^
return 0;
}
, I& E( b8 L8 b; y
int Push(Stack &S,SNode e)
{$ g& r4 {3 Z( k8 M+ N
if(S.top-S.base>=S.size)- h: n6 U1 H6 _  d
{4 W7 e' |) S; b- _5 B( {
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {8 i" d6 N. ~, t, _; t8 y7 a; G3 N
         printf("动态分配内存失败!");; k: Y$ S2 I9 v5 m! D
         return -1;
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;  g3 B' R' F+ v% o5 k3 v% C
}
*S.top=e;
S.top++;
return 0;& R# a2 @. L- \2 S
}

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;4 u: P( ~6 C' J% i5 }
}
e=*(S.top-1);* D. E. l4 x5 j0 k$ h
S.top--;% M0 ^3 B3 O9 y9 W, \2 C4 S. }# y/ L
return 0;
}! C0 Q# r; Y4 P+ a5 g2 t+ C# P

char get_precede(char s,char c)' y# T. R7 Z, m, X1 |8 ]
{' q- r0 B8 R( T: A( G9 j
switch(s)
{
      case '+':
      case '-':+ O7 s1 k- ?- i# _0 Q/ C
         if(c=='+'||c=='-')$ O5 r4 Q" H3 r1 c' r$ o7 W0 t- r
               return '>';
         else if(c=='*'||c=='/')
               return '<';# b' |% M7 `( I
         else if(c=='(')6 u9 ]- P' Y3 b3 R; T- U2 {8 r4 r
               return '<';
         else if(c==')')* W2 C' o, r" K9 F7 q
               return '>';: T# O9 n% _! |7 k* K3 D3 v
         else 6 O* Z1 q! }% E! o9 t; \4 \
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';/ K5 s+ W. b' L! j
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return '<';4 Z- h& V3 P5 O- y: P
         else if(c==')')
               return '>';
         else5 _7 W) g7 s' i* [8 Y+ Z# O
               return '>';+ f. t$ f3 @: @6 ]
      case '(':8 {; z& A4 O6 U, Y9 @
         if(c=='+'||c=='-')2 ^4 X7 f1 o; P1 \1 T. P9 A
               return '<';
         else if(c=='*'||c=='/')8 k7 K9 Y" B; P3 c4 D+ W# z
               return '<';6 b. s; h' ~' P7 _3 U
         else if(c=='(')
               return '<';
         else if(c==')')# \4 W' I" a8 u. K3 h" d% {* [
               return '=';
         else) d/ Z) s7 Z) T
               return 'E';
      case ')':2 t, e1 g6 b0 |  \, C
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';& M# a) F* C) I0 \
         else if(c=='(')* ?+ T- i: U# ~1 [4 h
               return 'E';
         else if(c==')')" j$ E( }, P2 k+ |3 D
               return '>';/ k& }, ~6 v6 v" R1 i( f/ _
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')* d6 D# ^+ n; O( i7 t' v% U9 ?
               return '<';. j8 ?8 L5 G/ N7 j' R! z7 f
         else if(c=='*'||c=='/')
               return '<';0 q) \, ~  g/ M- k4 v1 C% g
         else if(c=='(')
               return '<';
         else if(c==')')% P; n. e+ _/ \1 h
               return 'E';9 Y' D- o6 Q8 Z; Q+ L) ]$ L
         else! _* v5 L, d1 I
               return '=';
      default:
         break;+ t, x7 c2 ~0 r( E% U8 L
}) q% f' |- C+ P! \3 x' |+ g
return 0; 9 R  T4 r1 E/ Z3 r( j" G; {
}
$ I2 C+ H' @3 o6 u5 F" \, J3 g+ d. R
int isOpr(char c)
{  z8 b9 y4 ]# U) d* y- @) w
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;* k5 ]3 i% @2 U4 [6 ]& X
else + x+ C( U) V, X' s9 z
      return 1;
}) h2 A* j* S1 X8 j- Y
1 b, y' e8 k" G: a% I, e
float operate(float x, char opr, float y)4 W2 x% D3 F+ k- H5 r% W9 ^
{
float result;. [) u2 ?' y# D. S8 |5 I1 l
switch (opr)
{4 ~3 }" v: A$ X% M
      case '+':
         result = x + y;
         break;
      case '-': & C8 c" z8 X: r  z0 o* ?3 K9 {
         result = x - y;: y6 W2 a' q8 ]: g
         break;- `2 q, C; K* N- P; w3 o
      case '*': 7 e5 x8 Q& B* h5 a: j. _3 Y+ R
         result = x * y;" w' V2 G" g2 Q, h7 t9 D% R
         break;! C# B8 v$ u4 I% _
      case '/':
         if (y == 0)
         {8 c$ |7 `2 y+ O9 t; ?! X
            printf("Divided by zero!\n");
            return 0;
         }
         else
         {% |$ {% ^7 N( p4 V+ p$ |
               result = x / y;& e- P& j/ }$ W2 H2 Y
               break;3 F9 W  j3 T7 C) q) x
         }
   default: $ L& C0 y! T! X9 Q) J3 n  R
         printf("Bad Input.\n");
         return 0;/ G1 q. u7 p1 u& ~! n
}
return result;9 f! M: l# N  L; l7 O' R  h
} 7 M  ~0 O) m) r, P+ L

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;* C1 u# t3 `; W: ^! O# ^$ b
char buf[16];
int i=0;
1 k) |- m! V  ~# q, Y% y( K
InitStack(optr); /*用于寄存运算符*/% g1 {& Z9 P7 t1 ?1 f3 [- |2 {1 d7 k
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
- ?2 X) c/ i" K8 s8 U
printf("Enter your expression:");) k4 x* Y9 J$ F0 U
      $ G+ a  @7 m2 U* a  o- h7 K8 n
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/, _4 a" P7 _0 W- H9 a0 M2 y
GetTop(optr,opr_top);
c=getchar();. i/ V+ l3 t" y  r4 p9 h
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
& K5 w( j  x$ ?# ~          i++;
* X! D! y! P8 _3 B          c=getchar();4 n' p1 @; Z) u( @4 V
      }* J8 c! |/ a$ q/ z
      else /*是运算符*/
, ^3 K* q  N& T/ b+ _" I' B9 a" V       {: J: @' B, A& u$ t( d8 ?
         buf='\0';
# Z% e  i& |' Q( T9 x          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/$ s( U# k3 B1 z2 X# u
         {
7 \  x5 t* K+ P# A; X0 x                opn_in.data=(float)atof(buf);
! L% l" e2 V* n0 g* a                Push(opnd,opn_in);% y$ o1 z; U" s, o: j
               printf("opnd入栈:[%f]\n",opn_in.data);
5 w: e: y3 o3 V4 }6 B9 V2 M0 Q% v                i=0;) T. ~% j- p2 C3 b" s
               memset(buf,0,sizeof(buf));
6 T& g" I. a# Z. \0 Q4 N+ o! @$ m          }6 l9 }: g" G8 g! H, T, @/ t
         opr_in.ch=c;
1 I7 C+ X  i  i! l; p! R6 \. U: c          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/: }+ [  C  S& L: k
         {
3 G. |8 i6 W) v             case '<': /*优先级小于栈顶结点,则运算符入栈*// h2 Q& G2 _0 G0 j" ?4 P5 c
                  Push(optr,opr_in);. w" T+ g! u, g6 H; s+ _/ J
                  printf("optr入栈:[%c]\n",opr_in.ch);
/ J. |" a5 U1 Z0 N                   c=getchar();
- ~7 U/ m/ G& O$ f                   break;! p4 X+ Q1 ~) [) p+ [$ T; {
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/7 m& G2 a, b2 W
                  Pop(optr,e);
/ f  T4 e8 S- i$ q' }                   printf("optr出栈:去掉括号\n");& d7 p( \  m- [8 z# c
                  c=getchar();2 q' L4 m0 X/ ^1 H, _1 Y( K  Q
                  break;
5 m; U3 x+ s: W* i+ A9 g! T! r& X             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
; i, q: b# z4 H$ @* g0 D                   Pop(optr,opr_t);5 w% B- c7 I4 X1 s2 T- l. J2 ]2 J3 |9 H
                  printf("optr出栈:[%c]\n",opr_t.ch);
# c8 n' ^8 `/ O" q0 S5 X                   if(Pop(opnd,b)<0)
. ?, p& T4 ^6 ?, S1 g0 L  K  s                   {: |! o& f$ E' P
                     printf("Bad Input!\n");- t- c+ h, C, p9 @
                     fflush(stdin);
6 Q$ D- [  \" N: ?$ \                      return -1;3 C/ v" V8 b8 `) N3 d4 ~6 a+ J
                  }  I  q- ^3 ~6 n( a
                  printf("opnd出栈:[%f]\n",b.data);
8 n# w5 S, N) t3 |$ t                   if(Pop(opnd,a)<0)1 X5 G/ E& O$ P
                  {
; d! p3 P+ N) H                      printf("Bad Input!\n");/ J* m# r, F9 H. A7 J
                     fflush(stdin);
# I  m8 j& j( f5 s# a                      return -1;$ j9 O$ N' X; k$ z6 E
                  }% R+ L$ x  y6 K# Y
                  printf("opnd出栈:[%f]\n",a.data);
/ p, ?1 K; P- k% M3 y+ q                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/' n# [  `* T4 O0 D
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
/ \/ _. L# v6 s' e' m( f8 e( C                   printf("结果入栈:[%f]\n",opn_tmp.data);
  T! J2 f% p& Z8 w3 [4 h) q                   break;7 O7 l2 Y6 Y5 q1 {; y1 t' A
         }
: z$ k, R4 I& K- J* D       }
( ?6 s+ ]( p3 g8 G+ {3 d9 q5 }: }+ a       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             # W; w2 G9 n; d& E0 s1 T0 D6 m* M
}
* [! d  d$ v" j* @, \, F GetTop(opnd,opn_tmp);0 H; A" M8 [! y
DestroyStack(optr);
6 x+ \! w; m3 x' @ DestroyStack(opnd);
% }' G6 H8 h- d/ F return opn_tmp.data;
+ \8 i2 f! `. U& G2 ^( w5 l}; Z2 |1 X# u+ H$ n: ?/ r. ]

) r- W6 Z7 \* E  o. c- T- {char *killzero(char *res,float result)7 R* z8 G' ]+ s# y: [; o
{
/ ]& u- G2 Q* ]! H' ]4 f0 m int i;
9 M8 W9 j' V# r$ {6 }
4 I3 ]& y/ \, _- Q/ a sprintf(res,"%f",result);" T4 @  I* @; I; L4 P- T
i=(int)strlen(res)-1;. a% N7 V& Y: Z- \. {7 X1 `- R; L
while(i&&res=='0')* [7 {2 b2 L2 u% s
{: g) q3 `9 Y" t2 [: Y* }0 z  u
      res='\0';
$ N6 c" R/ A/ ?1 h% \       i--;; `& u, o0 ^! I
}
% J1 s0 m; ]) r* ` if(res=='.')" A3 F$ x+ X1 m) @2 H4 C* A3 r5 l
      res='\0';# O, M0 f2 X& n
return res;/ m, K) y, Y4 ]0 y; O) I
}" o6 i" Z4 g8 P3 F

( V4 K7 V( k, Y7 Dint main()
# B* [/ M* T0 u" x% F+ I{) \& D0 |- K; Y
char ch;& p1 k: a+ x9 E9 N8 T% G" a
char res[64];
8 w" J3 [& d! e4 }! A float result;6 }4 I: U, o. p: S$ i+ {
while(1)' [& [: |8 X" @7 x( D: t0 U
{
( Q$ h+ P1 e) F$ _; d3 P" t       result=compute();
) ~# k6 r" @* U       printf("\nThe result is:%s\n",killzero(res,result));' S' G% R7 q% S& }- [  F
      printf("Do you want to continue(y/n)?:") ;2 j! B, r' ?9 L" P: Z
      ch=getch();
1 ?# l$ f4 @# q4 l6 g9 ^8 `       putchar(ch);6 f& K: [  L. D, Z+ [+ Y2 h/ I
      if(ch=='n'||ch=='N')
: B; P# V* d8 G/ X8 J) k          break;  a) @$ {: E: ]- l6 ~* e
      else; Q- W6 n, ?, x+ q3 U: e2 o5 z
         system("cls");
, d* k9 t0 @4 f% ^ }
$ a8 b1 E$ V1 p( f return 0;
# S! b% |1 ~% Y: H! R4 @- e7 Q}* Y* [- f" c$ K7 h/ f

[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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