C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.1 `7 \; p7 m3 t/ S) l/ T
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=# v9 S' \- ]# W  u; U: D0 e
/**************表达式计算器************/0 R- e  t5 ~8 U9 `$ j7 L+ B* [
#include <stdio.h># g$ W7 P, D$ |! i! A. w
#include <stdlib.h>
#include <string.h>
#include <conio.h>: [1 K) _7 p9 S2 I
#include <malloc.h>1 T) `1 c7 Y9 T  J
/ L' J' I- ]3 @, W& |  }! }1 q$ n
#define STACK_SIZE 100' W: W* R. Z3 i+ @: [
#define APPEND_SIZE 10* T/ p% z5 i. \( w
. C. o0 N  s! s, x
struct SNode{
float data; /*存放操作数或者计算结果*/0 M) x  J% R" N+ X) _; l' z& N
char ch; /*存放运算符*// Y, C/ Q: K- _- m& _
};

struct Stack{/ b* u. |: u# C# m9 h- n' @
SNode *top;  {1 k, d# E% I8 j; u& l/ o, R
SNode *base;+ K6 z' z" U2 K% \$ J4 c
int size;% T6 E( [) R" T7 ]& W' A5 K
};
& a" @  i& K, k2 R
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/5 P1 C$ Q0 {* t& G
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/" K2 _# E" |9 t# I  r+ E
int Push(Stack &S,SNode e); /*将结点e压入栈*/7 H! E, ^- Q! S
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
8 R- m  {3 u, L  S
/*表达式计算器相关函数*/: A1 g1 @, F1 a& 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计算后的结果*/
float compute(); /*表达式结算器主函数*/3 N2 j( v! v' g; f$ `
char *killzero(float result); /*去掉结果后面的0*/ * x, n5 i, g" ^) V$ \

int InitStack(Stack &S)0 {$ ~5 q0 Z! O! c  {, X- c
{6 q3 x3 {0 M* N# u. v
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));. b& G' {+ \, K1 ]# z" W3 p% X/ ~
if(S.base==NULL)
{
      printf("动态分配内存失败!");6 s  }1 i/ [2 s0 k, ^5 P9 p7 V
      return -1;9 _" N" ^8 x4 \% L2 s3 d
}. K! U8 T+ ^3 C$ @, l* g& k( _* m7 \
S.top=S.base;
S.size=STACK_SIZE;
return 0;* n5 Q. m8 [" L( }1 |% Z9 [
}: V6 h' E1 T, ~3 s
) W. z7 O+ |+ i* l8 k9 p- M7 b
int DestroyStack(Stack &S)
{! T2 v- |- {& ^9 J
free(S.base);$ S: g. B; y4 S  N6 F& c% V
return 0;
}/ e7 z0 F8 q, W

int ClearStack(Stack &S)6 @4 m, A' w6 w' Z
{
S.top=S.base;5 y/ w; W/ |2 t* I; e
return 0;; U/ o( c, a* \
}9 @' ^9 V! |3 Y

int GetTop(Stack S,SNode &e)! D' Z/ f3 [  j- r) C+ Q, N3 t
{& R+ y- e* p0 {! |9 q% ?
if(S.top==S.base)* @2 C) \' K  A; y$ U! Q
{
      printf("栈以为空!");
      return -1;
}: [% n; h" F$ v* A
e=*(S.top-1);
return 0;
}: k- R1 Q8 q$ W' |0 {$ m8 j
) h  E  }8 Q7 T8 Y8 {
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)! n& I- O% r4 ]" p* m. s
      {2 L+ b% s) X# _: `, U8 ?0 [
         printf("动态分配内存失败!");3 y4 L+ x' D2 {0 R2 u9 F
         return -1;) N  R9 w2 t+ G5 |3 \. V9 J5 X- ?( @) q
      }, j" U; i- Z3 P) d% [
      S.top=S.base+S.size;7 c1 I* L# B8 I$ ]; D# D% |
      S.size+=APPEND_SIZE;1 R3 F2 H: F! A
}5 M; R! ^+ F8 O4 Z9 e
*S.top=e;
S.top++;) p  }) Y" O) y3 l
return 0;$ b8 Q) W; U3 o9 [3 m
}
3 k; O' d) P" y1 Z
int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)) l* H4 z4 x/ {7 _* i' L
{; v# U1 O2 \& E9 X: g7 C
      printf("栈为空!");5 G' l' O% x' B5 m+ N( Q0 _) |
      return -1;
}
e=*(S.top-1);/ u9 g5 S) Y2 I- I3 n
S.top--;
return 0;
}

char get_precede(char s,char c)
{& A2 l) W; B) J, e' D& {% c
switch(s)
{! g+ V2 L; W2 a4 ?) Y9 e! X. l
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '<';! F+ D, s* F, E: F4 c: J
         else if(c=='(')( J3 ^5 y3 h8 @& n$ L
               return '<';
         else if(c==')')
               return '>';6 Z, `  N+ I) C0 @! V; j+ {
         else 4 I6 Q) A6 G! e3 Q% }
               return '>';  r) J4 ^; [" Q* C9 }
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')! {& G( A4 G1 @4 Z; n: M" t2 S
               return '<';
         else if(c==')')5 ^+ K3 j& E8 N% j
               return '>';( f) u" u" Q1 S, ~* P- I
         else  |1 ^" k' Y( D$ _
               return '>';  u: }2 _2 W1 p* U
      case '(':
         if(c=='+'||c=='-')# P* r7 o: N* a4 W5 C
               return '<';5 g# {. u; J  A( n+ K! e2 J( S3 i
         else if(c=='*'||c=='/')
               return '<';4 N) i5 J: _$ g( a. K
         else if(c=='(')
               return '<';3 R! ]% o3 }, I
         else if(c==')')) Y4 Y2 N% ^% Z' \
               return '=';/ ?7 c8 q1 G& u
         else
               return 'E';0 a+ r/ G/ ?6 ]* _
      case ')':
         if(c=='+'||c=='-')5 O$ n& c2 V7 v0 i# y/ `$ t
               return '>';) ~, o' Q/ S$ \
         else if(c=='*'||c=='/')
               return '>';& j# {! ?, Q; A
         else if(c=='(')
               return 'E';
         else if(c==')')
               return '>';
         else
               return '>';
      case '#':' _$ d+ k* t) o
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';1 v9 W- |  y9 p
         else if(c=='(')
               return '<';% z0 M+ C: F# L7 w9 e  Y
         else if(c==')')8 i" R4 {# Y; b
               return 'E';  h: @, x' r: g% M' t* M' {% h
         else
               return '=';
      default:7 _7 @, H& K( [
         break;; k9 ]6 |4 B9 ]( ~' }
}
return 0; / q9 g. b1 n/ S% ^; ^) m$ V8 K
}

int isOpr(char c)4 K& s3 w4 Q/ \
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;5 E) E8 W; g; m$ \$ `$ @. m
else
      return 1;
}
- q' [. n! c2 h4 i: u" e
float operate(float x, char opr, float y)" E( \6 D# x7 G) g
{7 G( i3 I& u& |6 l
float result;  Q* a2 q2 `1 c; O1 j1 z
switch (opr)
{- F4 Q& d. h: e$ _% P" [
      case '+':
         result = x + y;# K- r: L+ ^! n4 ^% y, x; _% [, e' k
         break;* E! c0 p& U  a  x
      case '-':   V9 B8 _! F; I
         result = x - y;
         break;0 ]! k! |4 @; E6 M
      case '*':
         result = x * y;
         break;
      case '/':
         if (y == 0)0 O4 f' f: Z' W+ V
         {
            printf("Divided by zero!\n");
            return 0;
         }+ |' s, d0 e# ]
         else# S+ M* u2 Z: ~6 r/ P1 G2 ~3 M
         {
               result = x / y;( w5 }; t9 M" t- k1 y
               break;- {% P9 H3 ?$ ]4 w
         }
   default: % s9 {- Z( ]5 @6 J7 L* _
         printf("Bad Input.\n"); 8 u1 d4 f' g: I6 T2 V. p9 X" \
         return 0;
}
return result;. ~+ y. f) ]1 q: l8 {9 L$ Z( z
}
9 g3 ^9 U, K3 m# k1 u% m8 F% p' F
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{3 s2 y5 r) Q- [" Q$ o
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;$ Z4 a2 o. Z: J1 N6 `
char c;
char buf[16];: B: L6 i( T8 g8 Y) D  Y& q. Y
int i=0;
1 T: N6 x1 p$ y6 m' I+ Z, }5 W
InitStack(optr); /*用于寄存运算符*/- v6 x2 l, K. ~1 K3 g2 e, S
InitStack(opnd); /*用于寄存操作数和计算结果*/5 G2 c; \' a! U; V
memset(buf,0,sizeof(buf));+ t7 M; U7 t+ p+ X0 u

printf("Enter your expression:");9 S( z0 D1 t3 q: P/ Q$ v# e. g
      ; |1 c1 D: `3 ^- _5 ?8 y  T
opr_in.ch='#';6 ^# i4 [; V6 ^- Z, q
Push(optr,opr_in); /*'#'入栈*/7 {0 N6 T6 j& B: O0 W
GetTop(optr,opr_top);
c=getchar();2 R- J7 Y; M# ?* t0 e
while(c!='='||opr_top.ch!='#')
{# {% x" q% ]1 K% ?! m4 s
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/. v+ u  X+ R' r$ B, r
      {
         buf=c;' e7 F- a3 J9 ]
         i++;
8 W! r4 w, f9 Y5 L8 d5 s          c=getchar();
: E7 G5 ~1 z& W       }
# u. ^  I6 ]3 t) L1 L7 v       else /*是运算符*/, X. L; z' y! B1 U4 F
      {; p+ t" [0 E: c/ y
         buf='\0';2 z$ I0 u% `3 j7 B8 q4 P
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/( E8 w1 {1 k$ f3 v, r
         {" u* A6 L! J; w8 l# t7 L# [4 }
               opn_in.data=(float)atof(buf);
, Y6 B5 g0 V% C( Q/ q2 @4 y                Push(opnd,opn_in);
1 I) d% @" y! P0 K# p                printf("opnd入栈:[%f]\n",opn_in.data);
8 _% A) L- A% e# R6 E, \+ S! T: R                i=0;
8 R1 t4 a4 z) V6 M! b; @                memset(buf,0,sizeof(buf));, }" n* P4 `0 y
         }3 i# k* F( L) a  s, e3 l8 k
         opr_in.ch=c;" x: t5 f+ A" s
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
( {& }& @9 @5 Q( j; H          {2 {+ {9 d7 b& ^& }8 f4 G2 o
            case '<': /*优先级小于栈顶结点,则运算符入栈*/7 Z, C) z, |/ V$ w7 q/ p( Q5 E. K
                  Push(optr,opr_in);
6 q. l; _) ]( s) w  b                   printf("optr入栈:[%c]\n",opr_in.ch);
  W. L0 U4 e* u( n) t, i6 H                   c=getchar();
: ?, V4 y9 L: Y- F                   break;% r8 z" N" }' X- H
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/$ W3 f8 U; T, I$ @" Q- a
                  Pop(optr,e);
; I0 M, p5 r4 G7 O! D6 Q                   printf("optr出栈:去掉括号\n");! ?% e! Q( \6 M% z& T' [
                  c=getchar();
9 Z2 K5 r9 X$ D# B- y                   break;
4 U& B/ r. j1 J4 H# \             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
  y7 H2 ?  s9 [  H                   Pop(optr,opr_t);1 L9 v3 Z- M3 W, l9 H0 H& u& J
                  printf("optr出栈:[%c]\n",opr_t.ch);9 Z# V$ [& c( b6 k
                  if(Pop(opnd,b)<0)
  A1 |: e( Q/ u                   {
" |; t$ u) j7 \! D9 m* A                      printf("Bad Input!\n");
1 C- Y0 m2 p' e( T" G+ w4 p                      fflush(stdin);
) Y. b- c% y' N/ T4 Q                      return -1;
& ^2 t9 S% J, I/ z2 K                   }
3 j* V( w% i9 W' n2 l4 K                   printf("opnd出栈:[%f]\n",b.data);2 X1 k  x  l% ^! f4 I
                  if(Pop(opnd,a)<0)
" v6 G4 H( Z) x4 {8 w+ C                   {4 i8 A+ s& v! A, Z3 A
                     printf("Bad Input!\n");2 d) j* q1 [4 F
                     fflush(stdin);/ h* @5 a' c" t5 o2 H& j
                     return -1;
8 q2 y! C9 A: _: w1 G: v                   }
7 r0 s/ Y$ ?1 [. J6 K% E  T0 `- L& }                   printf("opnd出栈:[%f]\n",a.data);
. T* a0 R! t0 W2 O5 h                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
1 n; Z4 G1 e1 S! @1 |0 h- n' f                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/4 t( J, \1 ~& ?; s( R5 c# w
                  printf("结果入栈:[%f]\n",opn_tmp.data);: l8 f8 `* S, y  Y! @
                  break;
0 J- U2 `: Q' m          }
, S, m% T6 r" b! M- V- o       }
7 Q5 h% U4 j! N  Z1 Q       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
2 I. `0 y$ t6 z- U6 L/ t }2 d* V1 W: g+ R! b/ a/ x
GetTop(opnd,opn_tmp);2 S, P  q: _, {+ }, ]* `
DestroyStack(optr);
DestroyStack(opnd);
, ]1 a: R6 E3 G: u return opn_tmp.data;1 P6 |) L1 J$ K  x
}
; b# T  G, ^3 \' x# e6 r% ^0 `+ |: e4 g
char *killzero(char *res,float result)
8 ]' T  Z  {" |% e9 K$ @{; N6 Y" n7 }4 Q! C* R3 {7 `
int i;
5 _1 x( x! |9 e& T3 X3 _0 W" m3 v& W
sprintf(res,"%f",result);) y6 `/ Q, `' }# Q5 P1 g7 Z
i=(int)strlen(res)-1;
: O5 x- r8 J! z; X- g# t6 m while(i&&res=='0')
% Y  p0 h3 h, b9 f( N8 U {
6 R9 X, m6 f# V3 u4 n, R       res='\0';, `$ G+ |3 B2 {
      i--;
/ T& x$ |& F* V& x/ y- U" [9 A0 O }. ?* s4 k& j* J, C8 o- D
if(res=='.')
# Q# V1 C# D& g8 X/ Y( c4 F' B: M       res='\0';/ I6 y( o4 z& l$ g+ k. N9 ~" s
return res;
% R$ [; V- M% c# ^3 ?6 L}
' f3 a0 I: k4 D, j6 R
2 o! T. f1 d" ?) M; Mint main()
) x2 r2 E+ g0 W{
) u- L# h! b5 }1 X char ch;% J- g5 w% ~4 a$ `# O
char res[64];
$ U: t, i1 K( P/ [5 j3 B float result;* e9 l: i; J0 _
while(1)
! S6 e+ {4 g# D; H {6 H" E; t& v% S, u
      result=compute();6 ~& n7 E" Q3 `  G: ?: v. s, X
      printf("\nThe result is:%s\n",killzero(res,result));
" o+ |- b& L1 x/ @0 n! m       printf("Do you want to continue(y/n)?:") ;1 t6 {* w1 f! t! _8 D
      ch=getch();5 n  d+ O" u6 m- v7 N  M" q# c2 _' s
      putchar(ch);4 y. y0 J/ G1 K/ M- `! @) T
      if(ch=='n'||ch=='N')
/ {! d7 `5 w8 a3 v6 H8 F3 o) P; h          break;3 n0 U4 D) E& m, }, W
      else+ Q- q/ F9 q) Q! l
         system("cls");4 ^$ }4 _3 z8 t) t& T% Y# r
}, T! [( I5 V/ h& ?1 f
return 0;( H( h, ^" {$ X$ R3 x0 E2 q$ E
}
4 M' L  B1 c4 {* Q0 ]# H: p
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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