C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.7 j; C) e7 a: w, _/ K9 e4 h
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=7 W- a! h3 D# o- f9 {
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>4 m/ _8 `# o: w" i( d
#include <conio.h>' x3 [. g5 q$ V5 @
#include <malloc.h>0 C' f: l; o) R2 N0 b0 y
/ _0 i$ b2 }, s; y) U9 n5 ?' S
#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{2 V2 _; [2 F7 W" `+ U8 k
float data; /*存放操作数或者计算结果*/1 \  |3 h; p3 W! v! r% H% L+ T
char ch; /*存放运算符*/  ?. j" d. E: J$ o, H
};
0 L. m; U; Q7 \& C7 s, s8 j
struct Stack{
SNode *top;
SNode *base;9 t& a3 z& I' W6 m$ d
int size;9 j" m' O; f/ N; R+ P
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/- Y& y% v1 [6 M9 [7 k: R% C7 T
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/* R% _1 e5 @" K- a" f
int Push(Stack &S,SNode e); /*将结点e压入栈*/- m; ?0 |) S2 u* L/ z& l5 C( M
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/; h; M. I: ?+ S7 q/ B9 O
7 |9 ^- T& H' y6 g6 v' v: `
/*表达式计算器相关函数*/! J6 X8 Z+ [) x  e: k8 N3 F0 `5 @3 H
char get_precede(char s,char c); /*判断运算符s和c的优先级*/  Z5 }0 B% ^9 z* o3 X' {
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/( E4 U  \1 @5 U& h4 z
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ ; x1 e- r7 ?6 k
0 H5 Z2 p; x$ I  S6 H4 A9 R
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");) I1 j3 G/ B9 h1 D
      return -1;+ W0 S6 B5 n/ s9 x
}2 h  @6 n+ R8 a' [, q( ~9 Y3 D
S.top=S.base;
S.size=STACK_SIZE;; W% s; S6 l6 h5 x5 N
return 0;. @( Y; }) `$ J
}
; l% w7 H" i0 i3 f4 a8 \
int DestroyStack(Stack &S)8 S. Y  a* m  [6 I: Z
{
free(S.base);% \, P( V; w# ?, j2 a' D; E
return 0;
}

int ClearStack(Stack &S)
{
S.top=S.base;
return 0;
}
/ ~% F  C7 Y5 E0 a9 b1 `7 ?
int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)
{2 z/ z6 \( O, S" d, s+ l
      printf("栈以为空!");) d) y4 R, P. h4 V( x. j6 I$ M) U/ L
      return -1;
}, ]* r: T2 _5 v: }9 |( Y' s+ J
e=*(S.top-1);
return 0;
}. v( j  S/ q# L9 R. s9 O
  h# ^# S' M: a( d- ?( V4 A
int Push(Stack &S,SNode e)# N, O; n' s' U9 r$ Z
{4 y! s5 V2 I. g# u, `0 Y: G
if(S.top-S.base>=S.size)  H  h# Q2 F* g" I: m) m& Z3 j  \1 t; g
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)# {6 _/ H: J( ]* {5 k
      {+ m4 S' Q, X/ j
         printf("动态分配内存失败!");
         return -1;
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;) O6 i- @  l& J  ^. C7 K
}
*S.top=e;7 o2 d8 {/ J" Z9 j, e% R
S.top++;' C5 ~5 |- M7 D. ]) o
return 0;
}

int Pop(Stack &S,SNode &e)  V: n0 A9 K, m- u4 L( {+ z
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;" m1 l' C7 ~3 m, D  U
}
e=*(S.top-1);/ n5 W# C& l, b; ?% v1 J  ?
S.top--;: m; }2 R( u$ R7 F; b$ ]& }' S
return 0;
}, L8 Y2 I* ?! i3 ]# \8 ?0 O

char get_precede(char s,char c)* i7 ]( ]1 I, E
{
switch(s)/ P9 I2 b$ K5 G4 V' H4 a! E0 q
{
      case '+':
      case '-':+ ], `" M/ d4 N) \7 H' A" e
         if(c=='+'||c=='-')
               return '>';: i8 |" |' C2 v' k. D; z
         else if(c=='*'||c=='/')+ S" ?* d; }$ j+ ~
               return '<';4 G: f: k9 U, U. \: _$ P: j0 }  \+ u
         else if(c=='(')% d" [* s! \# X7 h! K
               return '<';6 Y( e  {; u4 c3 H. l4 Q! G! i
         else if(c==')')
               return '>';7 C& ]) x* x: o3 @. m
         else # A- k3 ?0 x: O
               return '>';9 f0 t5 M/ w" f# a' ^+ E9 {7 Z
      case '*':+ ]; `' f3 h0 K; N' S+ ~
      case '/':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';8 d4 F+ M9 c) U) V
         else if(c=='(')3 n5 l1 J( H/ H
               return '<';$ r. P) I3 u3 P2 D+ p- h, L1 \
         else if(c==')'); T$ F4 |0 Q: u: O9 U
               return '>';& h3 E! _  t2 t! g5 |  g7 Z
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';0 m& Y: d* H- x; r
         else if(c=='(')
               return '<';6 O) r$ u0 b- {0 m9 T0 U8 B' z
         else if(c==')')9 g# U: m: T5 \5 \) K7 V8 u
               return '=';
         else
               return 'E';) u; F( H1 R1 B6 S5 Z( y
      case ')':7 p8 j( V8 T7 N- A
         if(c=='+'||c=='-')" L9 z- z9 i9 T  I" P" ~  |
               return '>';1 k% i4 V& Q9 Y0 l/ e# d
         else if(c=='*'||c=='/'): v9 h# m$ x6 Z
               return '>';
         else if(c=='(')
               return 'E';
         else if(c==')')9 f, ^: W# F9 o2 B
               return '>';
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')8 Y2 d6 E8 b+ n
               return '<';
         else if(c=='*'||c=='/')0 H' ^" ~! Q' e4 r# W* E# p
               return '<';3 y5 ~, ]$ U; N# y) J
         else if(c=='(')
               return '<';, x4 h, O' Z* c/ x% o8 R
         else if(c==')'); i% h- Y8 X* Z- |
               return 'E';; [7 A. a3 g" t# n3 g8 f
         else, ~0 h; _. ]/ V) f
               return '=';
      default:
         break;3 g0 }0 T% k: [% F% [7 t5 K" E
}/ {! Y& ^( T' A
return 0; ' `" p$ m+ Z, s7 g
}$ ]! x4 |6 O: e) W5 ~9 g, O! \
9 A* z: S$ o5 [' @9 i2 \
int isOpr(char c)+ e/ r. S" k0 p7 e, l5 G
{, ^) U4 E1 a& J- D, i6 `$ j% Z
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else 0 ?$ w% C; q+ M9 J5 t) a9 T
      return 1;
}

float operate(float x, char opr, float y)
{
float result;* h  P+ S) [. \( c
switch (opr)
{: {1 b% C/ r* w8 b; n
      case '+': - L0 P) c4 Y) e) x6 [' e# B
         result = x + y;8 l0 Q5 W# O8 d9 e$ ?2 ^7 O3 G
         break;, r! I8 E& T. V: _
      case '-':
         result = x - y;2 _! P! q; f, Z* W' D
         break;" T5 q* f8 L; q- W% C. ?* d8 M
      case '*':
         result = x * y;
         break;
      case '/': * j9 |1 x& Q& V5 H
         if (y == 0)
         {
            printf("Divided by zero!\n");! w4 F% a: O9 `; `2 n8 s
            return 0;/ j: f5 X( R/ ?% }  H2 e
         }6 A, y7 w/ c- l( T
         else
         {
               result = x / y;
               break;
         }
   default:
         printf("Bad Input.\n");
         return 0;3 w) |3 z  ^0 o( ]6 x
}6 Y7 L2 d' D! N' X
return result;; v* z0 a% M8 q; P, L
} * s; Q% z5 `1 r+ w
# v/ q6 k+ z0 x/ U
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/4 c& J" p% ~- U2 k# y3 f' P; w
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;& B  f4 L- \% L1 i3 g5 Q- A1 ~
char c;  J  `0 j3 ]% q
char buf[16];4 u" ~; m; I, `
int i=0;. V' p) A' n) [3 X& G  p6 m
; b8 R2 K  V) j) T  E- S
InitStack(optr); /*用于寄存运算符*/. h% @2 o% [: j! |% ~
InitStack(opnd); /*用于寄存操作数和计算结果*/  e4 k5 C. L( H7 d
memset(buf,0,sizeof(buf));( G5 U; M( e8 g! `( `  O$ h- y* U

printf("Enter your expression:");: M3 `( S3 j8 u! {9 O; \8 O

opr_in.ch='#';5 M  I% I6 f0 X# m6 S
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();- _. E  [' U, h
while(c!='='||opr_top.ch!='#')
{2 N/ ^8 o# s- `4 h+ F  y
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {; Y/ `* w% l$ L9 }' W
         buf=c;0 `" x9 C4 W( c' p1 I& z
         i++;1 c1 Q/ l, ^; }, j# o9 D
         c=getchar();+ U. Y- M* A3 t& Y$ Y. E- U+ |
      }* j: C  `% d. o
      else /*是运算符*/
& j, S% p0 Y5 C( T       {
% x8 y; {0 g" Q8 h1 f          buf='\0';
# ]; P" {! p8 L9 l' g          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/1 P- s, x* R+ X7 }! {' M
         {4 Z$ p: c& d1 I& ?% Y
               opn_in.data=(float)atof(buf);
. w9 _# I& ^; x& k' x                Push(opnd,opn_in);- G4 b, q  Z, ~) Z. K7 z! \
               printf("opnd入栈:[%f]\n",opn_in.data);% a1 @* m( P9 \1 q
               i=0;
" `3 z+ j- S7 s; u                memset(buf,0,sizeof(buf));) n# X1 s  J- i( d4 ?. [9 f! O
         }$ Y; O0 C7 ?! W& y. [- z4 |; S
         opr_in.ch=c;3 o# z; i+ x  N+ D1 `
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
, {9 S8 b4 V- K, J6 Q7 Q/ x4 d          {# d, L& z( x, V# E3 `. {7 {
            case '<': /*优先级小于栈顶结点,则运算符入栈*/. d9 p8 [2 Q1 o/ J3 d/ E0 M. [
                  Push(optr,opr_in);/ x4 p7 f! G* v  A8 o
                  printf("optr入栈:[%c]\n",opr_in.ch);( c) z8 ?2 J2 _( H" x6 H' @
                  c=getchar();
- S( l; {3 i" h" n9 }                   break;, S; G+ L- u: `8 B4 K
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/; e) {$ g/ J3 L# z2 z( l# Z
                  Pop(optr,e);
( R* u- N/ r/ |$ s1 s2 s- S                   printf("optr出栈:去掉括号\n");! _; e& q2 X* I/ E! B% x% o; f
                  c=getchar();
1 B! e% P# c9 L, m                   break;
; c2 b. Z4 j& ]6 ]0 c0 Z) Y             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
4 D4 Z/ v# U& @4 p                   Pop(optr,opr_t);
9 X( H+ j; w) x; {) h' w5 P                   printf("optr出栈:[%c]\n",opr_t.ch);
! g" d( Q. [6 Y1 B                   if(Pop(opnd,b)<0)- g$ |8 P" y0 |7 V& \
                  {+ o- m4 w0 e2 X. k
                     printf("Bad Input!\n");& c! ]6 I) F+ C3 x+ J. b; M
                     fflush(stdin);
* H( u: l9 J/ W. V7 e5 n2 G                      return -1;% H+ l8 A5 o6 K$ {5 q
                  }8 |  V# Q5 A6 d
                  printf("opnd出栈:[%f]\n",b.data);
1 K( \. S8 S" t6 Y" l                   if(Pop(opnd,a)<0)1 j$ ?/ q- T2 @
                  {
% K. W* w7 e, a' I5 n* z                      printf("Bad Input!\n");9 |: j  T3 [" \2 Q' X% w
                     fflush(stdin);: R1 y; b; I1 `/ Q
                     return -1;
4 G. m3 ?2 s- A: i, s. u* q                   }
9 ?, r  K3 M5 C, Q8 w* m8 V                   printf("opnd出栈:[%f]\n",a.data);( W/ `/ g& x: g% O9 y: S
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
" u. x1 S& H: r" Y& [# X, Y8 x                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*// @  R( N% f6 Y/ ~2 {
                  printf("结果入栈:[%f]\n",opn_tmp.data);8 J$ q2 W; ~: L% r, g4 H6 ?
                  break;; L8 a3 S1 q. i  f& A
         }. g/ L) [! e$ [. ]4 n9 b
      }  N, }4 S- R$ ^+ M, T. ~. l5 ^- T
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             $ p1 J3 }5 Z' y
}9 ?, U) b0 Y/ t' }/ R9 a* K
GetTop(opnd,opn_tmp);
* U9 c% W9 L1 p% O) ? DestroyStack(optr);- Z6 C  O! O7 f. q% p
DestroyStack(opnd);1 N# d2 M8 x6 ?7 `9 R$ _
return opn_tmp.data;7 ]/ c+ \9 I; m( ^/ ^% ~
}; {" Q! z1 o8 `% O1 Q

( y. f, l9 R& S+ g1 u  D+ rchar *killzero(char *res,float result)9 o  z2 j% R- `+ t) V3 M
{
4 Q4 v0 T- d% G" R$ |- j int i;
6 V( u- G; @) \* m3 m8 S
1 F3 m- s8 l7 Q9 v sprintf(res,"%f",result);
% w5 I3 k( r. i  t i=(int)strlen(res)-1;
5 P9 w" M+ x, }+ G( a while(i&&res=='0')
8 |* ?/ e8 c4 V2 [ {
# R" N( S( n$ w9 A! H3 p       res='\0';! }, `9 K' N, L/ i$ r) m7 Z
      i--;
+ K! D9 J' y$ `6 E9 L. |' L. [ }1 }/ A* V( ?, p: z8 |% z/ J( P
if(res=='.')
: L: U4 l" w7 L" }* |- d) T       res='\0';
% X9 k! x% X( _7 x- x  {& e return res;9 ?  {. V' g  ?% l
}
+ H3 A5 A9 X: R$ [6 O3 k) x7 y+ V% B2 t- D- q* P
int main()* o' [( R. u1 W2 {7 C- Y
{8 i- l* P" R& M2 [# H8 B: V+ l
char ch;, ~$ M0 w4 `, ?1 p6 H/ s$ D
char res[64];0 u1 w6 z. Z7 r( z. h
float result;, B8 R  A  a! y+ l
while(1)
  h" ?1 g/ e6 |6 `% } {& @& i- V' l& v7 {( P' ^6 ^* T, {
      result=compute();3 S( d5 v; T& C' b. r
      printf("\nThe result is:%s\n",killzero(res,result));
5 z' B; T7 J7 Z* O2 f       printf("Do you want to continue(y/n)?:") ;
: i9 x! ?4 k1 B4 C- f, v! k       ch=getch();
8 Z' h, H9 D# O5 B       putchar(ch);' W1 t, I. y" @5 o
      if(ch=='n'||ch=='N'); J, c. ]" }& `/ n; x6 j* K
         break;
/ x+ G$ S1 X4 c8 G( ^" X# U8 w       else
- d' `, h( y! R: b2 q$ K1 }          system("cls");
% s: i$ g" r, y, Y$ I, g& ^ }& f$ }3 ?! ]; u. j; t& y1 o! |+ z) Y# ^
return 0;
% H& A0 f6 L; |* W3 t2 X}
! d8 y9 ?; ?- T/ n3 R5 I& r1 o. d' ]/ y
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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