C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=3 s0 B  I7 ~0 e" O4 }
/**************表达式计算器************/
#include <stdio.h>7 H2 v! i2 w' \9 }, v+ E
#include <stdlib.h>, S& c# ~# e& n' I) T
#include <string.h>1 N2 X# L$ r$ c! `
#include <conio.h>  ?0 W7 l& F& z  q) `
#include <malloc.h>
5 J0 E2 x% t/ Q% h
#define STACK_SIZE 100
#define APPEND_SIZE 10
4 e: l% D. s$ V7 f
struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};
" d8 z( @: R; d' I
struct Stack{
SNode *top;
SNode *base;8 F( i; G& E1 n. S: K0 X
int size;
};

/*栈操作函数*/- s# [6 z3 j) l! R
int InitStack(Stack &S); /*创建栈*/6 c: h! Z+ N' k  n- o( ]9 x
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/4 U% _1 J! a) t
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/% N3 m1 M6 _. T5 V+ l
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/, e) l$ i% T1 `8 e, ?
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/0 p8 `5 u  s. q3 K4 m8 R, P
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/# |$ l& O2 \+ m+ Q* U! i
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)8 P$ Z$ m, I% I' _  l9 f2 q
{2 p- E) _9 n3 r+ j7 @5 O( ~$ k
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{: `/ ~, ^3 p  M3 K$ S: ^
      printf("动态分配内存失败!");
      return -1;, ~: G6 o3 d% X
}& Z* y% S: O& E
S.top=S.base;$ b3 E' l$ u4 N1 r, r
S.size=STACK_SIZE;
return 0;
}
+ t) W+ o: p5 Y6 y
int DestroyStack(Stack &S)9 r; w1 O7 @3 \- _2 N7 w0 b: Q/ V
{! o! j+ F- S* b9 B8 D' L
free(S.base);! j9 J# q( p( n
return 0;+ W' V/ Z- a4 Q) e
}
3 G2 ^& x- u2 f( p1 G' _
int ClearStack(Stack &S)
{
S.top=S.base;& I* a% t' d( z' H& ]+ c
return 0;& C3 Z: Q8 }( d+ @9 E! Z) V$ c
}& F8 l% }% T+ l" o2 N- G& x
- K/ ^2 _- w) p. m
int GetTop(Stack S,SNode &e)- ]1 o9 k( `4 J( Z$ i! Y3 J' s+ z
{
if(S.top==S.base)' o' {, Q# c) m
{
      printf("栈以为空!");3 H0 u# u( ^, S
      return -1;- }9 G# Y; V( W0 s7 P8 h
}
e=*(S.top-1);2 @6 E: p8 u4 x
return 0;
}; |/ ?3 z1 `. `& F1 Z" m

int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)9 S# F, H+ h- S/ A0 @% I+ H
{. ^: \7 [! O$ n  x8 a) Q
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));/ P* c$ k& e/ o4 \3 y9 J
      if(S.base==NULL)7 X- s5 N# p% O( r/ ?4 ^
      {3 u1 y3 b. i) @( w% N9 M
         printf("动态分配内存失败!");
         return -1;, R& S# o, f. C& k" y: f7 O9 i  v
      }, @3 ?" o' c/ }+ i7 J
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;. h- u1 t5 U$ u, U+ b7 n
}) T8 _( A1 Z. ?+ w
*S.top=e;
S.top++;& I- M5 }) B* k. y" N2 U  v
return 0;
}

int Pop(Stack &S,SNode &e)
{* y* t' M  C1 j7 e3 g) B# Q$ B+ ^& p
if(S.top==S.base)! @1 B, a% p. G  Y' A  j
{/ R& n  j  C+ {' {+ S! O1 L1 Q) p
      printf("栈为空!");% W: A8 L+ s& N3 {9 T, P' L
      return -1;
}) q' e7 c/ t+ r+ I/ p
e=*(S.top-1);
S.top--;* R# s" J, l" b/ I' e' `5 l/ S: K
return 0;
}

char get_precede(char s,char c)
{7 r: @* o! N+ O8 l: M3 Y( t; H) }2 F
switch(s)4 D. ^7 S& q& L2 B* N' j
{
      case '+':                , I- H5 q3 l. Z- v
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')! r# |  o. i1 k% Q# d: }+ m# ?
               return '<';- b  j9 h% F9 I6 C" x! |
         else if(c=='(')
               return '<';
         else if(c==')')% y' i+ Q, E- m: H/ W6 V4 N
               return '>';
         else % S, b8 t6 I3 p0 _+ w% M# h7 P
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')7 k+ y3 f- L0 ]# g& I( N! C
               return '>';6 l1 o- [0 }) l
         else) k. F' t5 c/ Y
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')9 u! c1 s& W6 F' @$ I0 ?2 B9 P
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '=';
         else! I2 ]7 c( [/ }
               return 'E';1 S. k; n! Z: u! Y7 z/ _$ a5 g- c8 {3 b
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';0 A' j0 S6 c' x$ P
         else if(c=='(')
               return 'E';9 B8 a! m& r2 |8 w6 @
         else if(c==')')6 U5 q! z+ |0 w* M1 n
               return '>';
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';4 Q' L4 [9 }, M& Y3 S
         else if(c=='(')1 [* X* C; b" z2 y6 W1 |  M+ X3 }- n$ M
               return '<';) u$ L' A) d, h
         else if(c==')')+ Y: F$ S0 `; m0 D
               return 'E';
         else4 P; i9 |9 `" k1 Z% x$ r; S
               return '=';/ Y" o# ]- O) m. W7 m& |+ ?
      default:
         break;
}- W0 }. e: o8 d+ X7 x1 l. }1 P4 E
return 0;
}/ p$ q  N: T$ K6 I  {
0 q# Y. N& @. ]
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else
      return 1;
}5 x: u- C$ }8 w# P% j# F2 _
7 T5 ^5 V* e3 j; A5 g
float operate(float x, char opr, float y)6 ~5 t8 v& Q, e: C
{" g; ^( V6 _1 U  V, I2 Z
float result;
switch (opr)
{/ `- u  b6 b% V% b! @) v5 U& r
      case '+': 3 }9 Q; p7 P* ~6 P1 r/ l. O  f; C; R
         result = x + y;  e5 r, N, _6 N, @- `( [' D4 F3 V
         break;* [) x: E. q% a2 u0 g0 V- ]' x
      case '-': / ^* B2 C# q/ H* r0 }4 B
         result = x - y;
         break;/ j' a7 I  X$ I1 G; H6 ^3 {: h* S! t
      case '*': . P0 v3 h* N% F6 O' f- \4 t
         result = x * y;9 N" P) N; T; C& D: l0 _6 Y
         break;
      case '/':
         if (y == 0): N  M4 O: g, U3 ~% t
         {
            printf("Divided by zero!\n");
            return 0;/ u! ?) v& P8 S8 X* j$ X% Q
         }* u8 f* z; [  l$ k6 B6 i
         else
         {
               result = x / y;
               break;* ^& x6 T" J/ r; @8 Z8 B8 {
         }, n: I  m3 j1 C% R$ r; V
   default:
         printf("Bad Input.\n"); & w* o, x2 w! g2 `
         return 0;
}/ A1 Q4 e% H6 ]: D
return result;
} 3 Z3 f% P; z% U% c8 T
' P  v9 i& F5 Q. e4 g; j8 t9 z
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;6 G% u/ t/ K* J9 ^. I
char c;" l3 m/ e- L3 G6 N: l# W
char buf[16];# C' I$ z" q( r
int i=0;

InitStack(optr); /*用于寄存运算符*/1 j  Z* W! l5 s/ H" I
InitStack(opnd); /*用于寄存操作数和计算结果*/' y9 o6 P  V+ m/ s4 |
memset(buf,0,sizeof(buf));
! h5 R* ~' ~; d- N$ r( ]4 U: B" d
printf("Enter your expression:");
      5 v1 D9 R1 w  g8 @; e4 v
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();/ a! }. U4 F# W+ [9 a* C, T
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
' U  z) [! C+ s          i++;
' h- X7 q4 ]7 X, P& @( O          c=getchar();
; H) _$ [' Q0 p2 [4 {4 q6 ~, p       }4 P" h. y/ e! ]; U
      else /*是运算符*/- e" V, l# C" {9 B4 G# R; x
      {3 e! j) T% [4 h
         buf='\0';  F8 [# W/ P" m% m. v# D
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
6 Z/ C8 g: h% K          {4 A& I( B+ [9 ~
               opn_in.data=(float)atof(buf);
* u4 s$ r% N1 R: K# s3 j; x# {                Push(opnd,opn_in);, S9 T" }, F% E; E& i# {- j; [
               printf("opnd入栈:[%f]\n",opn_in.data);
' X) y- Z7 I* I8 Z8 ?2 [8 s                i=0;2 q9 g$ W% p, {$ ~: d6 h) }2 N) t
               memset(buf,0,sizeof(buf));9 i5 v9 N: x1 B; ?
         }7 V3 }2 X) i+ C! R6 h) k/ N
         opr_in.ch=c;
0 ~8 L, l/ j0 ^$ W, I  F          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
& H4 L" N6 g" h, m- Y9 n. V  \          {
; e5 U2 V; s/ N8 D; s) n+ D: H             case '<': /*优先级小于栈顶结点,则运算符入栈*/4 |  ^6 U: E9 [/ g
                  Push(optr,opr_in);
5 I! D) v! I1 S0 V                   printf("optr入栈:[%c]\n",opr_in.ch);0 V, T" A% `' F' _% e5 b, c
                  c=getchar();
: ?' Z1 W' W( ?                   break;! W8 E6 m- k$ i; B8 M" k$ x1 U) l* \
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
* G7 t' n; V+ `8 Z7 d$ U, z& w                   Pop(optr,e);
& A% K- |; M3 ~. I3 y: W) m+ X8 n                   printf("optr出栈:去掉括号\n");
& T+ t, R9 D! b5 T' V                   c=getchar();
( Q5 r% w! |4 U& ~                   break;
8 F# O$ |5 ]6 J4 n5 g             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/: y6 Y' {/ @) p% ^# F
                  Pop(optr,opr_t);
! F( x/ C9 N3 {7 \0 h7 k                   printf("optr出栈:[%c]\n",opr_t.ch);
  ~; m" G3 w8 X8 E                   if(Pop(opnd,b)<0)
1 F0 Y5 C8 d% }6 R8 c                   {
/ P! X4 m) a3 w( e# E. Q  X                      printf("Bad Input!\n");
5 K1 }! m6 W4 H% A2 F7 T2 ^                      fflush(stdin);
# ^0 ^' S$ ^+ [                      return -1;
5 l9 m3 h% K1 Q; Q& V2 @7 j                   }
) i8 c" g* }- |8 T2 }- x# _                   printf("opnd出栈:[%f]\n",b.data);0 ]% `+ p7 M$ \0 H, b
                  if(Pop(opnd,a)<0). e2 R4 \% W6 o5 a; N7 Y
                  {
1 r" Z, L! m8 [) Z+ b                      printf("Bad Input!\n");* j7 O: N' L4 T  z
                     fflush(stdin);5 V$ H$ M  W: A, @. Z# S. [5 U" [! j
                     return -1;
( w) Z# i0 Z/ c                   }
) I: e/ N! p- P8 v, a5 t                   printf("opnd出栈:[%f]\n",a.data);$ a& L7 ^/ Q6 ]( b2 F7 ^
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
& A' }1 F1 \& o0 K                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
; Q5 U5 |6 P. r7 E                   printf("结果入栈:[%f]\n",opn_tmp.data);* u+ n. o9 ^4 ~3 [2 q: ~# p4 j
                  break;
/ @( ]. e- ?. i          }; ?: {8 N5 G. z4 a! N% `7 g" D9 z
      }1 H, e& Z  o1 D5 i7 p
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             3 M9 V: E+ z5 \3 E8 o7 r  W, x1 q6 N
}
* ~0 E  }1 P$ ]- Q: D: m% F* S GetTop(opnd,opn_tmp);
; Z( V- ^5 C' d' `0 _5 e% O DestroyStack(optr);9 _9 j" ~# \: X; ^, M7 p( g
DestroyStack(opnd);6 E" j+ w1 ?: ?. X3 |+ k
return opn_tmp.data;( C! S7 _( U6 {8 h% H
}
( ~% S/ Z, P6 [& X$ a5 j" P0 m7 T
char *killzero(char *res,float result)
$ z, v$ l7 v1 G, l- Z) i{
. w* O. o* |9 J% M9 H& c  P int i;
, E9 U9 B, B2 S4 t# y- S# o( Y! ?* T$ \! |: P
sprintf(res,"%f",result);
7 M  z0 G) @4 X  U i=(int)strlen(res)-1;: x8 b. K* p% |
while(i&&res=='0')
3 D; o2 T( @; |( {7 ]2 x6 k+ ^ {) g$ ~7 i. c1 |4 A8 ~6 ?4 H6 W
      res='\0';
; ~3 K9 v3 R7 w+ _5 _       i--;% g9 {4 u6 E! z/ j: z
}
# |. W: v: ^) B9 Q; V& a+ I if(res=='.')4 d7 t8 d& Q% t* |9 L: C
      res='\0';  D. V* n. F, }0 Z6 T3 u; y! p0 G* h; v) O
return res;
; i$ X$ ]& Y* z1 w* F- H}
% K* T8 d9 @4 x' k% ?( o. ^0 R: ^$ L# b8 N' s0 ]8 c( x
int main(), u. P* A- D) S% C
{& q9 w8 c, }9 P" F9 i8 `0 a5 [+ |
char ch;- w$ }1 |! M& f; }
char res[64];9 ~, J6 v* p& c
float result;
3 V, i) e1 e6 H/ X" R7 w5 Q) I while(1): D  m; c+ _/ _8 p9 ^2 {
{
6 V& W& A4 ]+ }8 ]3 Z, B" m6 E       result=compute();) P) l$ l7 K- R: X! \4 j& X4 `
      printf("\nThe result is:%s\n",killzero(res,result));
( L; `; r* M2 `, v       printf("Do you want to continue(y/n)?:") ;' E7 i! O" @% a* Z% H
      ch=getch();
6 q/ u+ l/ L5 ]4 J1 O1 z       putchar(ch);- `* O5 |3 N  [: ^6 ?
      if(ch=='n'||ch=='N')) G6 {9 @$ F4 {% I: ^& f
         break;9 v2 S8 W7 t; t" @
      else
) y# q& t* @% a- m          system("cls");6 r" W1 E+ p; q5 C% g) E
}
3 ]7 X0 k4 F8 t! R( c9 N9 |+ o return 0;1 w3 O  B+ `" v2 ^. y/ N; u% O
}
' g5 O% ~) y- b* I1 r0 k
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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