C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.5 i# z8 w& n$ i! J: a
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=! r- v; b8 F+ ~, J5 w. ^
/**************表达式计算器************/, A* h1 y. R5 X# H% S' i- v
#include <stdio.h>* ]! S! o$ o. P( t0 ?6 _4 y
#include <stdlib.h>
#include <string.h>3 G& T; y9 l, v& e& ^3 J
#include <conio.h>
#include <malloc.h># G) F' K% K1 D, x# Q, g
; {- P% h: P0 w5 }9 O
#define STACK_SIZE 100( R  R: k3 U9 ~, S& O1 r
#define APPEND_SIZE 102 [+ O6 F  ^$ a6 Z$ b( ^8 Y* X
) q0 v/ ]0 ~! W% {7 f# e
struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};) b; s0 K5 }( S8 r: B: ~
. v& R0 B& Q3 ?2 |* I% T
struct Stack{  O. D) w0 a5 e% ^* X; E
SNode *top;$ t$ b; G( n1 M! {8 B; V
SNode *base;! g9 I: |4 D( W1 d- H
int size;3 s, Y2 }3 y- W& M* _
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/" a7 W5 v0 n$ b
int DestroyStack(Stack &S); /*销毁栈*/5 y2 J2 Z8 |4 g
int ClearStack(Stack &S); /*清空栈*/3 E' ~3 E+ W: [3 ?7 ~5 x  t
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*// H0 X% J' W1 c. }' G
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/- U& \, E# ~+ ^
/ M. h3 G/ D3 l/ A( J0 Y0 O6 L8 ~. B5 J
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/- @- ]% {/ Q3 b7 {" i, N1 R" T$ m
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/( P  w$ p8 F9 m6 c
char *killzero(float result); /*去掉结果后面的0*/ ' ^  H; g1 L2 I% ^( B* L

int InitStack(Stack &S)1 b( G8 w1 O9 }# m" q; c
{/ C& X8 x+ Y9 E6 O
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL). {1 [4 N: c" c' ~
{! d+ r4 }8 X; l/ E; \
      printf("动态分配内存失败!");' i, ~- D8 v( t/ K' O) \
      return -1;9 B9 H4 P& `9 `6 J4 D
}* ?) P$ t, n" k! {' y# }, x
S.top=S.base;' q& ^6 e# M, }5 l6 X0 I. f/ C
S.size=STACK_SIZE;
return 0;
}

int DestroyStack(Stack &S)
{
free(S.base);
return 0;1 z- x# e: V5 M( t. |. y8 p; J
}/ }$ m1 m' }6 q. \( b6 b7 D

int ClearStack(Stack &S)
{$ ~* f9 K9 W& C; v3 q5 B
S.top=S.base;4 \$ `' D( s: V2 G& j
return 0;
}

int GetTop(Stack S,SNode &e)
{( P6 N' X7 E/ o$ F  o
if(S.top==S.base)  Y7 m2 D3 q; h( N4 w: b8 _
{/ l3 v+ d- v9 D
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);) h0 U9 @; a' |( {( G5 C+ e' S
return 0;3 d9 N2 S' ?1 k# C5 i9 ?+ k$ h  ]
}# h8 f: `0 L* Y, @! H

int Push(Stack &S,SNode e)+ R  |0 k! j' |
{
if(S.top-S.base>=S.size)( q# k! |. _9 X' Q  ?
{4 Z/ \0 L/ w7 h2 @
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL). X" h" s/ k* y. Y- }
      {, m3 b1 n( S7 v! a+ P) T+ f5 x
         printf("动态分配内存失败!");
         return -1;( x: u6 H1 n$ a& }
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}
*S.top=e;: F$ f; E6 s# G+ [# h
S.top++;1 v3 W) C( u( k2 b$ g# j% I
return 0;
}5 |# x; }: k# x+ [4 ?. |& f
3 T2 t6 }4 q/ B. o
int Pop(Stack &S,SNode &e)( e$ [' e$ t9 o4 D( W+ K: J6 b: H
{
if(S.top==S.base)- m" m9 Q% t* Y* O5 ]$ K
{
      printf("栈为空!");  O/ k# o9 s9 x5 N2 ^
      return -1;
}
e=*(S.top-1);
S.top--;/ i4 {: h5 [( z# ^, |
return 0;' S0 b" v# H7 A# M& A# m
}

char get_precede(char s,char c)
{( @4 ^2 ]* t; A: ~' O: K/ t
switch(s)0 a; M; t2 s1 f% g+ G
{) H8 f' o# I, E/ Q' W, ^3 O9 V
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/'). l: j) J/ {& U9 z- B2 e! |, x$ h
               return '<';! N% c& W; M. @# ^
         else if(c=='(')8 j. H- L! l% R3 `
               return '<';1 \: }1 I6 z5 q3 Z
         else if(c==')')
               return '>';0 r3 }6 L: |: y. N; u
         else
               return '>';
      case '*':( Q6 O3 l! k: z
      case '/':
         if(c=='+'||c=='-')
               return '>';6 q  p# C: V( a/ p! }
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')( l) a9 \0 q+ C7 g$ l" j" d
               return '<';
         else if(c==')')
               return '>';* Y' y; b" E9 _! n3 c0 _" ~
         else- B+ L- Y8 z3 d4 j
               return '>';& @2 q, o; U1 H0 f
      case '(':3 T- J' M; D+ D9 b. O
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')0 L( r6 Q9 |5 M# j, _) Q7 e6 `# x
               return '<';( ?$ J/ i! K* w4 ]0 x
         else if(c==')')6 l2 B3 I; s* m+ P- q3 k0 G& t3 p
               return '=';
         else, g& p  J! ^6 _% i1 O
               return 'E';
      case ')':) H2 A4 l$ Q) d/ C! @' L$ B
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';( v  x4 O+ p6 i( M, O" G' h5 {
         else if(c=='(')
               return 'E';! g2 z/ N, G" e, j* A" k$ i0 n, M
         else if(c==')')/ G; ]! q% a" x9 U* w
               return '>';/ P- C! G' H2 ?5 }5 b; Y
         else6 I0 c3 i% a1 P% |
               return '>';
      case '#':$ f$ _6 [' Q: |
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')! J; J- g: i! y# N9 T
               return '<';
         else if(c=='(')- R+ H( Q# N. ~* I: O4 J, A5 l
               return '<';
         else if(c==')')2 c2 `/ j2 Y7 k) g
               return 'E';
         else: V2 ^3 u( E+ p# d+ v6 u# t
               return '=';
      default:+ J' a2 w1 O" Z5 h4 u3 v' s/ {
         break;
}* N6 b& B  u) v
return 0; 7 C/ s1 _. b' o5 d# W
}
; ?9 a2 G2 i+ k. J; `7 n9 ]
int isOpr(char c)
{; K: p( S" i# }
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;" e9 t4 H: I1 q  z) D
else
      return 1;& W7 G% N% r. y0 p
}5 p7 A8 e* Y: v2 k6 @

float operate(float x, char opr, float y)
{, T& v$ s) Q2 v0 }3 @
float result;) K; A! f. e3 }
switch (opr)
{0 j7 E* R2 F' p4 }$ W: d& |, f: U
      case '+':
         result = x + y;3 I8 P! ~; ^* q* N
         break;5 G& @8 E9 k' Y' }$ }- ^
      case '-': ' ^8 q) {6 z# U$ J( F8 C
         result = x - y;
         break;
      case '*':
         result = x * y;  S: Z( V4 N  @0 l1 }, {' |& J
         break;8 j3 B6 F' f. `( c% M8 n
      case '/': , p& `0 b% ?* J6 F& ]0 F- }" B
         if (y == 0)1 R! K) o, \+ f3 Y& ]& }# ?
         {
            printf("Divided by zero!\n");
            return 0;
         }0 x: e/ C5 d8 ]' I9 V; I0 Q  z/ F
         else+ c* ]. O/ \& O, {; t  z7 E
         {! L" F" n  W8 d* j" n; `% D
               result = x / y;' a8 S7 [+ Q+ y2 ~3 @9 ?# q; z
               break;1 {' A2 M( b2 \$ e8 |0 w1 c
         }
   default: 1 J0 v4 J) T8 n) v% q3 s
         printf("Bad Input.\n");   F5 K3 m7 q4 [
         return 0;# b( f' }7 h% L; h' Z8 F7 r
}5 g7 L* k4 e1 [
return result;% \+ z! Q9 M! \8 A! F
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;: f% r: t8 I* w# c+ r) @( e5 I/ L
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;) Y6 F! s/ M* F2 j( y9 U2 y0 }
5 W2 n; W* T- A7 K8 v, Q
InitStack(optr); /*用于寄存运算符*/* H7 @0 B* F% B" t! o$ J3 N6 m
InitStack(opnd); /*用于寄存操作数和计算结果*/0 J5 {( i" V$ _1 i" T9 I1 @/ |
memset(buf,0,sizeof(buf));# r$ R9 ?: j7 A  O" K5 J  n
+ z2 |$ \( c: h" r% a7 ^; K, I
printf("Enter your expression:");

opr_in.ch='#';7 Q- k$ b2 a7 t2 ]0 q+ R
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);( j6 ^& h9 Y5 v1 v( H5 {+ ]
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {* c" J, w4 b" x/ m' a; F
         buf=c;; x* J/ X, ^2 z
         i++;6 Z' ]& F+ ]: W; ^8 C6 M+ p
         c=getchar();
3 K; b1 c, W2 @* \, c; W       }
* _% K6 _7 d2 J! E3 u       else /*是运算符*/
3 {0 _4 ?0 f! \: X( I       {  P& m- A# t" c
         buf='\0';
: [7 S  a$ ]# |4 J: I          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
% f2 I# R% u8 U$ B  X" G1 ]- F          {
$ h* @4 y/ g0 f& T. P! J                opn_in.data=(float)atof(buf);3 V! f: ?: |( n7 i; c0 D
               Push(opnd,opn_in);
$ G% O: ~5 M* x4 u                printf("opnd入栈:[%f]\n",opn_in.data);
% w% M6 Q7 L' N+ ^                i=0;
" A# G: E- `% u                memset(buf,0,sizeof(buf));
% e8 n5 |0 c5 `& U4 H  m/ j3 W2 a          }
7 R' ?/ o- ?# [! o" y# @          opr_in.ch=c;
! [/ s6 B0 z2 x2 p4 c0 g          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
% U' c+ U; Q0 N" `          {1 t6 M4 @- W. R9 o; D
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
" Z! T0 ~/ A6 X% f                   Push(optr,opr_in);
$ s" R; Y. r7 q2 ?0 Y. v* D2 r4 L                   printf("optr入栈:[%c]\n",opr_in.ch);$ }4 {: B# w' t# W& O% m
                  c=getchar();; o, ~" q2 B) {7 q/ X, c6 ^$ J- Q
                  break;
' ~9 {% [  y, R. S0 z. `             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/" t: j8 b: u$ z/ W' c8 v* p
                  Pop(optr,e);8 p9 S1 R2 ]& ]
                  printf("optr出栈:去掉括号\n");' K) ~! h' g9 J
                  c=getchar();) b4 P6 P3 c4 x% S' L  i" h
                  break;
# X' y9 K8 D/ A! X0 W' ?2 ^             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/! M3 E' H( _* q/ c. @' w% G
                  Pop(optr,opr_t);8 I' p; _' M# S6 Y9 e
                  printf("optr出栈:[%c]\n",opr_t.ch);
* J" ~) M0 S) c+ f( _* g5 S5 l                   if(Pop(opnd,b)<0)  f/ J) ]% r( q$ [
                  {" {+ e- `; c0 S' K/ r
                     printf("Bad Input!\n");
0 R9 N. ^: T. M' f# O                      fflush(stdin);  g& J7 G) R9 v* N- k. g
                     return -1;
  b  o5 |$ q( a1 \) J2 M  R                   }# \! T( S7 w+ m2 e. S; Y! @/ c1 Q
                  printf("opnd出栈:[%f]\n",b.data);
. \) T5 T' ]) y3 X0 w                   if(Pop(opnd,a)<0)
) J# \: |  k9 U( `! t! v# e* E4 |8 F                   {( b/ W) o/ R- F
                     printf("Bad Input!\n");
- b: P1 q' A) _% p* @% ?                      fflush(stdin);
* Q( t5 q: j3 `0 H! n7 @. g- k                      return -1;2 }! e0 J6 g/ l5 V8 `$ U
                  }! e0 C& z# [5 i  V
                  printf("opnd出栈:[%f]\n",a.data);
' L- r  K" k8 O) h, U! e% a                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
+ X) Y8 @! K4 ~8 M, v0 i                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/& S4 q$ T1 \# G! U$ r* W' d! H, [
                  printf("结果入栈:[%f]\n",opn_tmp.data);
# T; r0 a5 y1 r' L' X' N3 l                   break;9 ^% ?$ w! [* P* r, u* F
         }
8 C# I5 O9 w. I  O       }
& i5 W' l1 h% T$ F  T       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             + E4 j$ i1 e8 P% v. G
}
  |7 e& z- C* B4 y! [* k2 O GetTop(opnd,opn_tmp);, h* s# _- U" g5 W$ F+ Q( E
DestroyStack(optr);( V; ~) g8 _- z
DestroyStack(opnd);* v  f* i5 O0 [+ e7 Q( m! f
return opn_tmp.data;
6 d  \7 M1 U) [2 I% \) a- P}
; ]. r8 A; t5 R3 k7 x* U) d
( J7 K* _) q/ L' A3 Kchar *killzero(char *res,float result)) M* B! Y0 A$ s, U7 G9 S$ F. o9 Z
{) j6 d$ ]! t' s6 h
int i;' w5 B/ m5 b" N2 D* B

1 C7 {) {8 v, ^/ p- ^0 m7 x, { sprintf(res,"%f",result);
" |* J7 e: ]4 k i=(int)strlen(res)-1;% U- u) s& e. I! r" P
while(i&&res=='0')$ U% j9 o+ z1 P% Y1 a
{% B" D* [) @6 {- Z6 O9 Q* [
      res='\0';
" G& y& i3 Y8 R       i--;( n1 e; O9 a) a7 o* h; s, u
}5 C6 I& B9 b/ u( U: \
if(res=='.')
0 `3 _& x6 n$ h/ X! x       res='\0';+ W) q/ B9 E3 h1 X3 _/ P6 v
return res;0 H$ s  e1 L$ d+ t3 e
}) A1 Z5 ]: q" `( K8 ?

+ m4 Q9 F- T/ z7 q- b; ~$ v1 wint main()+ X$ @; O" T$ o- N1 H6 k
{
9 {% y) [' N* I* @/ f; |6 d$ e! r char ch;
' N' V% S9 g* N. q: j, I& r char res[64];; n5 l+ w7 ?- h+ D% H9 o8 t3 b
float result;- t) O- [1 a, Q
while(1)9 T/ R: y. [. `0 H% A# l/ a& ~+ B
{; `9 A0 G4 |3 Q4 D4 c# V9 a$ Z* |
      result=compute();" @4 u. ?0 D% |7 N
      printf("\nThe result is:%s\n",killzero(res,result));, x9 s& {- A7 j! `2 D
      printf("Do you want to continue(y/n)?:") ;
6 ^( [3 Q6 ^! R; b! A! @0 I       ch=getch();
3 A' ~* w5 y$ N. I       putchar(ch);, G! x1 C4 O# \  r" d0 B
      if(ch=='n'||ch=='N')' k$ t3 r% s4 i, I0 K3 g
         break;4 v/ A' J5 g: I2 @2 M
      else
: p3 x' e! n- n2 _2 r" k& C( p          system("cls");
# {8 M- G6 C, o: |. C0 l' T }
9 x% x$ f. c  y+ K0 e" B return 0;3 f% M' }& _* H  a
}

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

返回列表

C语言表达式计算器

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

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