C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/; w( p. }* E: Q3 J( s4 r) ~8 {
#include <stdio.h>
#include <stdlib.h>, ?: O# {" m3 m4 v' q4 P/ ~
#include <string.h>/ m* s' @# ?% X/ [5 z
#include <conio.h>+ g* C6 i% q- X2 b
#include <malloc.h>

#define STACK_SIZE 100$ ^9 l4 [, E0 C4 |$ j
#define APPEND_SIZE 10. y1 {. x5 E, E) f# P% T, U
* u' l/ h' O5 E! o# t; a. A
struct SNode{
float data; /*存放操作数或者计算结果*/+ s; _! f, A9 C9 v; _4 `" w
char ch; /*存放运算符*/6 |0 D2 o. b3 A& C3 U: Z: t
};
: b4 F* D: }& i' V) d9 ~
struct Stack{/ d  P9 T2 [0 `2 w
SNode *top;
SNode *base;/ R, g4 N+ _  q2 e
int size;
};+ z, y8 p: @+ n+ q7 C' B
; t( T1 _' G+ W$ X' Z. W2 t2 O. ?& T
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/2 S9 S" A$ N# A" R% Q& V
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/1 O5 h  t, J6 e9 G: ?3 v" J  F1 w8 h
int Push(Stack &S,SNode e); /*将结点e压入栈*/) h/ a) r! }: s& ]3 Y
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/( A1 c; L4 L5 I) D5 ?0 n# G

/*表达式计算器相关函数*/% C- M/ @5 ~5 d6 g$ q
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计算后的结果*/* ]. v- z: S' M: E- y% _% @( ~6 T
float compute(); /*表达式结算器主函数*/' i) I- N+ }, g- T! ?
char *killzero(float result); /*去掉结果后面的0*/ / w' @- t( \( F# y4 K. }9 S# k
! g( v$ o* d6 R+ f0 q+ Q1 z
int InitStack(Stack &S)( K% P( @! b9 m5 o0 r) U
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));( t6 v( {' m+ M( f, A
if(S.base==NULL)
{! J1 F8 B! ?6 D
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;8 r0 B# u) j& K8 V3 J- M
S.size=STACK_SIZE;
return 0;( Y  c/ L5 F- K8 b& _# y: `
}
( V7 Y- f7 [7 F: l# p
int DestroyStack(Stack &S)
{
free(S.base);
return 0;
}

int ClearStack(Stack &S): a5 e6 L0 p3 u8 w* ], r% _
{+ ?7 ?2 E8 Z5 X' \+ ?, I) _
S.top=S.base;
return 0;
}% N( A2 ?# L4 y1 I
4 s9 ~) t* |# Q# B
int GetTop(Stack S,SNode &e)
{* D  d) {' r2 S( f
if(S.top==S.base)
{* J. T  T+ A& e7 u  d7 s
      printf("栈以为空!");' n6 ~. ^8 T5 ?. n: l) y
      return -1;
}% `# V* M. s0 T, Y# y) Y1 ~4 W4 @
e=*(S.top-1);6 e9 s- F' ^0 X) r
return 0;
}3 z- y+ ^2 o" B( @' K

int Push(Stack &S,SNode e)1 N: e+ i4 G; J$ t
{
if(S.top-S.base>=S.size)
{' F' J: }0 w6 {
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;2 m( E) b: f# T' A; @
      }6 m# z9 ~6 |- I
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}* K" |  I5 R/ k5 L+ S4 y* {
*S.top=e;
S.top++;4 {% p( U& N& m; G( ^
return 0;  \1 W+ q+ D5 h" [% A
}% O% n2 e  f8 ^( Q. k
$ `; x( C% b: B! P# X
int Pop(Stack &S,SNode &e)0 Q8 g  P/ j& t+ P) h5 s5 g
{
if(S.top==S.base)
{
      printf("栈为空!");, `; _2 L* N' U! N. U5 {* s
      return -1;: ?6 ?& V% Q) ~- J+ p
}  ?5 l6 y, H+ F9 q& G
e=*(S.top-1);: L) a# h% ~. _* W5 p( O* d- M0 S. y
S.top--;
return 0;6 \4 r6 f9 g8 @% Y3 @
}9 U1 G& j7 X/ c4 s2 X
& i& R6 Q: X: A
char get_precede(char s,char c)$ \; V7 }6 c& M1 ]5 P+ @
{
switch(s)
{: W; k2 T3 u  M: `
      case '+':                " c0 U0 K  ^% Z  l
      case '-':
         if(c=='+'||c=='-')0 P& x% E& D; Q5 E- D: Y3 X# }
               return '>';% R" }& U, K5 w$ [( j- E, a
         else if(c=='*'||c=='/')
               return '<';. D; g. G9 n8 n' k8 Q# s% \
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';& S8 ]$ u4 T: b% t, [
         else
               return '>';6 R1 k! _# E1 T0 y4 h; U9 R
      case '*':
      case '/':
         if(c=='+'||c=='-')" e' s! z3 `) b& P
               return '>';
         else if(c=='*'||c=='/')8 Y7 F! w* g  q$ u4 g1 w' N
               return '>';( Z5 Z( N  j: z1 I- C' g  q
         else if(c=='(')8 l; o: @1 r( R; a5 g
               return '<';3 C5 r( p+ d8 {! B6 f2 c6 S
         else if(c==')')
               return '>';" [1 ]2 ?# l; }: Q
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';. h5 J1 z3 @7 i; w4 I5 @3 O  e
         else if(c=='*'||c=='/')
               return '<';- d$ D6 g. n' [9 F, E+ Y) l. p
         else if(c=='(')' X. o! W; k4 |$ ~7 W: |
               return '<';! s$ c4 Y( `, k2 H
         else if(c==')')
               return '=';
         else) ~1 e' }& W4 m% p  U! z1 n# E
               return 'E';
      case ')':& u. B( ]- g! e1 j% I* d% H
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';* L. Q4 n( e# w/ E8 Q3 V, B" a
         else if(c=='(')# d" _8 L2 s# j4 p+ ]
               return 'E';+ b3 D4 j' t" z0 p  M7 L) E
         else if(c==')')4 `) y4 C. j7 D2 V* }
               return '>';
         else
               return '>';) g- @8 n6 Y2 \$ }' o& S" b' S
      case '#':: u  ?# j1 o  _
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')4 q9 {! ^8 b& y5 C' f. Z
               return '<';  r! Y) q; \2 y
         else if(c=='(')- H" O" U8 T8 l) a
               return '<';
         else if(c==')')# r; H" c0 f, O, e9 r  [
               return 'E';* a; g5 X, ~7 v2 U
         else
               return '=';
      default:
         break;6 i3 _; X0 G- D
}8 D0 c" b8 J( k- w
return 0;
}. f+ s8 I! H  o0 l& l. ^

int isOpr(char c)9 G) f/ n9 J8 h- V* x
{/ N0 i4 Y2 i& ?) e# X
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')( |5 Q' |6 U  s/ F
      return 0;( n0 }7 h4 Z+ [& _' N5 H' @* e8 @3 X
else ; \" T2 D! E7 h2 \! n+ x8 Y4 T
      return 1;
}
+ r* F+ \/ {. A2 Y7 \; r: a8 X
float operate(float x, char opr, float y)
{0 z: Y/ u2 {8 V) ?: i
float result;
switch (opr)
{
      case '+': 4 K9 e0 _1 j# `% ^
         result = x + y;
         break;
      case '-': 4 C! X, d7 S* z. ]
         result = x - y;7 y/ Z7 S' F7 U' _
         break;# E# B- D: o$ I4 [
      case '*': 3 T) O/ b5 k) J, x$ _
         result = x * y;
         break;
      case '/':
         if (y == 0)
         {2 o0 E0 v* Y( |( J
            printf("Divided by zero!\n");
            return 0;
         }; g2 J3 h8 X& d) y+ E' G
         else& Q: y1 G0 R' {
         {) w% V. h3 u7 v% Y
               result = x / y;
               break;; B: }2 I4 v* V0 u
         }; }* [3 A* k7 S5 m; ~+ X/ I; M/ d
   default: , R4 M7 D& Q1 T' \# I& ?
         printf("Bad Input.\n"); , }0 S2 C2 n  r4 @, m- K
         return 0;
}, i; K# ^3 Y! G+ u& }
return result;9 b$ N" M8 `8 `" d
}
1 a, c4 d# |( g& G" c0 Z6 ]
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/. D$ z. {7 ^: W5 }: W: _9 i  V5 n4 ^
{& z! e. E1 ]$ {  [' f1 ~, q
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;" _/ Q+ v% B% J* g7 N% X' q
char c;3 m; }) |- A0 }  `1 G3 c# R3 p( \
char buf[16];+ q' U9 S& D- N/ S1 @+ l+ o
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");( b- r1 a* l$ s% K

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/* X5 }0 S1 Z' b3 s( Q- ?: B- q( C
GetTop(optr,opr_top);3 V3 B0 X  b! e5 k4 K9 H2 ]1 Z
c=getchar();6 @7 [; G$ u8 G- H' c
while(c!='='||opr_top.ch!='#')
{  `. j1 ^+ W# }
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/- D6 x- |" z; a; ^
      {8 z* k) y, l5 J1 l7 i, Z3 z
         buf=c;
" D$ M' j- K: Z: Z, N' F          i++;, n5 ~( [& t- e% b# g5 P
         c=getchar();
& Y# c) J/ D2 g! Y% [$ o$ z       }2 a1 b" K- m3 [9 B5 [" }4 w
      else /*是运算符*/
5 |% X; r7 i! v( o       {2 J$ X! y4 A, |& k) p% h) p! ^
         buf='\0';
% J+ f! H- t! \' f          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
* `  K. j9 _, F3 a          {
, T' U: F6 ^6 Y1 {                opn_in.data=(float)atof(buf);
  l* R$ f$ o7 e- ^; ]" x                Push(opnd,opn_in);
: g& T: v4 ?* c! m2 b; ^0 S                printf("opnd入栈:[%f]\n",opn_in.data);$ N, N4 E" a& F. i
               i=0;/ G+ B7 r1 f& M6 _* \
               memset(buf,0,sizeof(buf));2 y% W8 `7 X, g: G) }% m
         }. i/ }4 Z- S' ^% N" S  q/ m
         opr_in.ch=c;0 b% \. ]3 b) {6 v3 T
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/+ N5 F0 S. Q5 J) ?
         {; m: X% H4 B) u% C3 Y
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
0 e' i! I8 m& A7 x9 K6 Z) e1 G( [                   Push(optr,opr_in);
7 j0 f/ ~/ w* \# A2 I2 {                   printf("optr入栈:[%c]\n",opr_in.ch);9 d( Z. `; Z- U/ P
                  c=getchar();
: M& S% {, d3 H- j5 j' X* e+ Z                   break;
* t' @* o* J' U0 r# W  j             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
1 B- r, j+ {; B+ \+ q+ e6 |                   Pop(optr,e);
& k8 t9 \$ J6 Z/ ~                   printf("optr出栈:去掉括号\n");
0 L1 b% \, ?8 ?$ R                   c=getchar();' g/ l8 @: t: V8 |2 T
                  break;
" ]2 `$ c$ ]0 j4 s5 _( z, ^* e             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/- Z, X5 @( F! t
                  Pop(optr,opr_t);4 t' V' N" j! @  u- n
                  printf("optr出栈:[%c]\n",opr_t.ch);+ \! M$ n* ?! {9 E. K
                  if(Pop(opnd,b)<0)' q, }8 v) |! \8 s0 ?* Y0 I
                  {
! p& _$ E( D& u                      printf("Bad Input!\n");# |' N4 b$ r6 m
                     fflush(stdin);
1 Q3 b( \# ?2 w                      return -1;
6 ]+ O6 e: o# ]" h" v                   }+ ^9 S- I4 R# ~% q! r. i0 z- Y- L
                  printf("opnd出栈:[%f]\n",b.data);  Y6 P# P. L; l& D2 C
                  if(Pop(opnd,a)<0)8 y1 B( u/ z( [' Z
                  {# C9 r: P1 P1 V; z- C: ~1 v* z2 C
                     printf("Bad Input!\n");* D/ N) A- j6 C+ T2 @  u
                     fflush(stdin);2 Z8 o0 i+ A- Y6 G0 Q
                     return -1;
6 |' \/ F) K* Y                   }" b0 Q, q7 H+ `4 c
                  printf("opnd出栈:[%f]\n",a.data);
; v# [" L" S% @1 C. J                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
6 M! y! b. ?5 u  r. _1 ]+ W% ?7 d6 X                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
) t2 X) i' F* {' g                   printf("结果入栈:[%f]\n",opn_tmp.data);
2 U- L' \) j7 E9 r                   break;
  e1 Q# e$ v5 u, B          }
+ C9 h' h; u& |4 H; m- C       }4 f& b& Q6 f. ^
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
$ u$ S: n9 S3 A4 |* x3 x }
! R0 f0 A" e3 ?" d GetTop(opnd,opn_tmp);
( Z: y: T2 B3 \! V DestroyStack(optr);! ?' h! x7 m  @  P7 N+ M9 D
DestroyStack(opnd);
' s$ q+ x+ f$ B" q4 ?/ m return opn_tmp.data;: D9 D+ f8 V& ~! d  Z
}
4 A. X& f+ k* ~+ h. e
2 C- x; h8 X0 ^4 t# f# a) Z  H/ M2 hchar *killzero(char *res,float result)% ^5 F8 M( j  ^9 R
{
# S, D: K  x- w+ o  N, ^/ f int i;
1 S- f/ j8 o1 Y) P7 S
* @' a- A" k2 i9 q sprintf(res,"%f",result);+ {) \! f1 h4 k! T" U
i=(int)strlen(res)-1;2 ^" b& C3 P/ u0 a% S) h/ s
while(i&&res=='0')$ q% s; j" J) f, q  v
{+ j: v- c$ A" j/ m4 N4 p. r
      res='\0';
% e- f6 I  g3 a. S) @0 G" Y& L8 p       i--;
- m; A/ i* u1 e1 Y2 M0 a }
% i3 w5 {8 b% v# g5 v+ P if(res=='.')8 K- o' {9 H* O* A1 D+ d4 K: d
      res='\0';+ s, h+ ]& h+ [. H9 U% L
return res;1 @2 z* O1 ^+ L2 U8 |1 R: @" X
}
# u3 G, U2 {3 C# j$ c
& y7 \8 s: ]$ U5 w/ ~" [  A) kint main()
! y5 C9 ^9 ]  k: ?( x" t{
1 h: m" ^: j0 ? char ch;
* j/ `1 J# p6 B$ L6 I char res[64];+ H% k, \* |! F
float result;$ U1 s; P* g! |' i+ p' a6 a
while(1)0 W) a$ J2 p  l8 L* `4 x$ I
{
/ k" j4 H, ^/ {       result=compute();
3 M% M2 V% C, b3 Y4 t0 b       printf("\nThe result is:%s\n",killzero(res,result));  F7 h7 C9 D8 r1 ]9 s
      printf("Do you want to continue(y/n)?:") ;
, G- ]( s$ ]9 I       ch=getch();8 G4 E8 U8 S; ?. k1 @' J8 r$ r
      putchar(ch);4 \) j5 G: R) y3 c3 N, l- w% [
      if(ch=='n'||ch=='N')! N& ]0 n. J: O7 {0 `! |
         break;6 \# I7 O- w. N# ~5 S; p+ y2 e; _, ^
      else
7 ?! s, ?9 s$ I6 G# L! \$ h7 r          system("cls");5 @& F( a$ d& m8 K
}! C& Y( U, j7 D& S
return 0;
1 v$ e5 x3 W; ^0 j$ N/ l% _& T}* Y. Z. t! C+ S+ j- @) |
" o5 i0 d$ a5 {$ B! F
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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