C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=9 Z0 R" m' m* g& ^
/**************表达式计算器************/4 ?3 q0 C7 I9 v, \% D
#include <stdio.h>1 z( h# n6 e& |
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>! v8 l6 b- |1 M
  @/ f) E7 Y  Z! H+ K
#define STACK_SIZE 100
#define APPEND_SIZE 10" X) u0 X& J& t! O. |2 v

struct SNode{. H" u& f/ W6 Y. j
float data; /*存放操作数或者计算结果*/6 z! C3 r4 N& ^4 q% d' L+ s# x5 t
char ch; /*存放运算符*/
};

struct Stack{" Z" y; E# d- d+ x: W# u* p
SNode *top;; t$ H$ K1 c6 {+ X, b6 i
SNode *base;
int size;; ~$ |9 l) j1 X3 H) Q
};5 e8 N8 Z" Y' s0 ?8 H; J
1 _4 i* f+ S& a: I  ?4 `1 x% Q! K; [
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/; }0 H6 ~% U) y' K

/*表达式计算器相关函数*// T: `, F3 E! l: \2 {
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(); /*表达式结算器主函数*/: b/ h( X% r: ^/ q" o
char *killzero(float result); /*去掉结果后面的0*/ 7 R" x5 s& [8 K( L% q# `

int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));( b0 ]" A2 I" |5 K. W0 a
if(S.base==NULL)
{
      printf("动态分配内存失败!");2 D8 ^$ V- G. H) Z
      return -1;; L: L  A1 f3 O
}' G; P0 h+ ?( A9 P; a. ~7 x/ D( q' C
S.top=S.base;
S.size=STACK_SIZE;
return 0;
}

int DestroyStack(Stack &S)" f/ W2 l5 q7 f
{9 N5 s/ D$ A1 k6 `9 x3 Y$ F
free(S.base);8 O7 I3 r" Y7 k2 K3 V: Z
return 0;
}" k/ Q/ z7 S8 J" v1 x) Y  \

int ClearStack(Stack &S)9 N; {9 ~* j, W$ o) k2 Y2 I
{, T8 q, |5 Y; r7 |) ^
S.top=S.base;( ]/ k% A; V/ g$ u7 L, R5 c
return 0;
}

int GetTop(Stack S,SNode &e)0 `1 [7 u7 a2 ?& ^
{
if(S.top==S.base)
{5 f( k/ |5 E. j7 R" U
      printf("栈以为空!");5 V' a' u+ @! l2 x1 \% ^% L
      return -1;
}
e=*(S.top-1);
return 0;8 z  q8 u1 \/ m" i
}- B- K7 y9 \- C" I: [  a7 B/ [
! @" b  R( _* V% D
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{, z) z7 z3 Z( W- K$ h$ P# L
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));1 Z* h3 _8 V, k' K$ k2 g  J
      if(S.base==NULL)1 [  Y9 K+ ~( A
      {
         printf("动态分配内存失败!");7 F) o6 R; Q" o  ^. _0 v9 s
         return -1;
      }
      S.top=S.base+S.size;8 K$ i6 l3 R0 W- X5 ?
      S.size+=APPEND_SIZE;0 r1 N) p: V/ i6 E; p3 w6 `
}
*S.top=e;! ^$ ]9 J9 ^5 _' c
S.top++;
return 0;  U3 U( S9 x% P+ b
}
4 s; f; d# o& _3 Y+ \6 z& E
int Pop(Stack &S,SNode &e)4 G9 Z- }: w, K1 z
{( ]$ H6 d( o, W# {& P# T
if(S.top==S.base)
{
      printf("栈为空!");" w( `- @0 l: @5 ~. e, n! S
      return -1;$ V: D+ W7 k: j) W9 O" ^. _( `
}% E# e( N7 B& g3 @
e=*(S.top-1);' J8 R- i" L" i& M0 Y
S.top--;
return 0;
}. H% g2 ^8 }& {9 s

char get_precede(char s,char c)
{
switch(s)0 B& s- ?9 ~% @) N
{
      case '+':                " Y3 T- b, y; k. B1 N7 v; @& j
      case '-':1 S  {' `" u4 h3 Z8 E, j2 F
         if(c=='+'||c=='-')7 D+ \: a$ n3 I( `+ S8 \
               return '>';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')" J3 A5 w: ?( h9 G' t3 ^4 H
               return '>';% v5 V, C9 a# p6 N" h
         else
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')
               return '>';" d/ @& Q( ]1 I& L# C( R/ H
         else if(c=='*'||c=='/')+ G0 I; h8 m$ V* a. ^/ ]# X
               return '>';
         else if(c=='(')
               return '<';* S2 R3 G5 f9 `5 y2 _- w- a$ |
         else if(c==')')
               return '>';
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')) {+ Y& E! x" }
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';- Y( z& U$ w& |; f
         else if(c==')'). B3 [- I+ Q9 g  Y3 G, a- p8 r
               return '=';) `  \$ j3 G. p
         else
               return 'E';
      case ')':
         if(c=='+'||c=='-')) o/ Y  ?& ^( _$ L
               return '>';
         else if(c=='*'||c=='/')4 l  M% e" ^% E" f1 N' a# T
               return '>';
         else if(c=='(')7 i. i. e) M1 @+ i
               return 'E';. U2 S: h$ v& \2 @5 i$ v
         else if(c==')')& o" G9 p! g  e  B# c/ ~
               return '>';
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';* Y) ?9 B, M( b) T
         else if(c=='(')1 e& j+ d, q% ~  L4 m" _* P
               return '<';
         else if(c==')')# y" A$ n( r  i2 J/ _
               return 'E';' v+ U7 i& q4 i% S. N& L: ?: g
         else  G7 F( e0 g" o4 R) c' p
               return '=';
      default:
         break;
}1 g! l4 U( P( h. M* [5 V; V4 O
return 0;
}. a5 Q1 n0 D' T6 [" |

int isOpr(char c)
{' A1 y5 o* q- [1 n5 C6 u
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='='), G% w: G8 P, n" m- D  o' P3 n, Q
      return 0;
else
      return 1;
}
1 r! ~* N9 W+ e5 L; j
float operate(float x, char opr, float y)/ K2 S6 G/ ~) ^) [$ [3 G
{. x% ^: X, L9 Z& I
float result;3 l8 Z6 s4 b8 E7 {
switch (opr)
{
      case '+':
         result = x + y;' B4 t# f/ j! Z5 ^
         break;/ t9 q; B7 ]9 Y
      case '-':
         result = x - y;
         break;
      case '*': 7 F; q. ?1 g8 y) x, M
         result = x * y;
         break;
      case '/':
         if (y == 0)0 H+ n8 x, ^1 C9 S- @$ h8 W0 Z
         {6 m3 H% I* S% e
            printf("Divided by zero!\n");8 {- k+ H# H# V0 V8 x- R$ ^( B# a  s, b
            return 0;
         }7 K( L! z1 s8 L6 }4 u( c5 p! T
         else
         {. y7 p0 D& A$ @( t- @7 _$ M; i% r8 s
               result = x / y;/ F) c6 [- z0 D9 z' e, l
               break;
         }
   default:
         printf("Bad Input.\n"); 3 I9 H- A2 z5 x, i- X/ P
         return 0;1 n0 M8 K; C- ?' u8 Y) T) j9 }2 k
}
return result;5 o. F2 E* j; ~
}
0 _/ H+ J1 `% I. N# K
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/4 B) Z( F; R; U
{
Stack optr,opnd;, {, N( U- l2 U# X9 e
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];/ }" C1 p9 c9 J/ i8 [; d* p
int i=0;

InitStack(optr); /*用于寄存运算符*/% V, A/ l) d2 H8 Z( i
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));$ X1 g# O& r( W. Y4 ~
/ X+ d5 Z9 E( S0 I# o
printf("Enter your expression:");

opr_in.ch='#';4 Z6 I' p# a4 ]& M/ {9 h8 C
Push(optr,opr_in); /*'#'入栈*/8 |( T0 ]  d1 V; a$ m/ E
GetTop(optr,opr_top);
c=getchar();2 o9 s& H; I: ~3 M1 J# D, A5 H; |
while(c!='='||opr_top.ch!='#')( ], }+ p9 L- \* @8 S4 s* n5 g
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/% l6 J; W& e' d( S) b. p
      {
         buf=c;
. ?# o( C2 k4 H6 n7 N! |          i++;& X8 E4 X' b/ D- F0 x9 s) q: h
         c=getchar();
3 C: U/ r  [& U# X       }+ O3 N0 s) n# ~; g1 |" ]
      else /*是运算符*/
9 N8 ?) g8 \4 q( X       {! L7 ~' p" w5 l5 `! l
         buf='\0';' ]; |8 {/ `+ o0 r
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
. C& Q* ^' }; k5 @          {
- u; y, |) E! p- c4 k0 a                opn_in.data=(float)atof(buf);0 `" h* {3 E+ M& H6 u, o3 r+ h8 B. B
               Push(opnd,opn_in);
) b1 [  x9 c# [# t                printf("opnd入栈:[%f]\n",opn_in.data);0 ~& G( T3 ?. p9 p2 m; ^2 d1 e7 g
               i=0;# R; D' G; c6 n: Q8 q9 u
               memset(buf,0,sizeof(buf));
  `& N/ v: Z' C8 v) {) A          }
/ e+ `4 ~8 }3 r! }5 \1 m" a6 v  w* f          opr_in.ch=c;
  `1 N. Q* W4 S: g8 h          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
/ J3 F/ t/ Z0 |$ N$ e* Y          {% ?0 n6 H6 B& D' c$ {' y
            case '<': /*优先级小于栈顶结点,则运算符入栈*/, M) B& _- T, ^; C2 ^& B; J
                  Push(optr,opr_in);
1 B6 \+ R9 L# W3 X                   printf("optr入栈:[%c]\n",opr_in.ch);1 x2 T9 M; G- X; D1 z6 T( O
                  c=getchar();6 W) k9 M$ R0 z
                  break;
0 z$ S0 P  d! G' F; ]             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/" r' u& A/ s. k* A
                  Pop(optr,e);
4 W0 g# I3 M  s$ a                   printf("optr出栈:去掉括号\n");$ u; k' ]& c6 W1 a- m( ]
                  c=getchar();- Q4 C$ V7 H) B. s, A
                  break;9 @% P, ?! i' _' S5 j* K, c. G
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/! R& C/ t! l9 p
                  Pop(optr,opr_t);; _- A. r- }1 f+ L1 f
                  printf("optr出栈:[%c]\n",opr_t.ch);
* V8 k) `. \- b& _( ~% C                   if(Pop(opnd,b)<0)8 G1 h$ C& P" t& x+ @0 R: d
                  {' \" `* t3 S2 s+ [3 v! ~' I
                     printf("Bad Input!\n");, K, j" f' D) G) h* n
                     fflush(stdin);
: g3 d* s, r. V! Z9 Z$ \8 X                      return -1;3 _3 R- |4 `6 k( ]* y3 S
                  }- i- @3 Z8 _6 }  L  Z
                  printf("opnd出栈:[%f]\n",b.data);
" c/ i% ~$ X7 j7 h. D                   if(Pop(opnd,a)<0)
7 L9 G8 l% B+ R                   {
1 ?% M) _% U1 q+ ?# [                      printf("Bad Input!\n");) i5 T) d6 d' l, C, ~& J
                     fflush(stdin);
/ q2 w# Z% c: X: v( R                      return -1;) @3 b; k5 Q7 l: x5 v+ R
                  }
" Z; M/ f$ E; e3 z                   printf("opnd出栈:[%f]\n",a.data);
+ X' Y. E+ V3 c! Q7 O) H! `% Q$ @                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
  M+ ^( }5 p: l& n; G+ N! S                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/6 s6 o" G. y; |; t5 g
                  printf("结果入栈:[%f]\n",opn_tmp.data);
6 C! E" l, c7 B* K* [; ~/ e1 N( R4 D                   break;( f( y; T1 Q( ~" W- F& C$ \
         }7 |, h7 w3 D2 S" ^3 e$ t( O9 l5 @
      }& P6 T4 O' p5 D7 d" ^) [1 c
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
# g3 B7 o6 Q- h1 z. j0 J# |) E }3 i* M8 @' }3 ~/ @7 p
GetTop(opnd,opn_tmp);) X- E$ l8 e1 C4 q8 d
DestroyStack(optr);5 T' k' w" |8 O0 \1 {; E
DestroyStack(opnd);
; i  L: m5 Y+ [  P9 |* G8 q% a; [ return opn_tmp.data;: h4 \- n2 n) ~3 r; ^& q0 q
}
  k9 W& w* x  H1 w, h! v: n, A
1 Y/ U- G- U) H- S* T' S% G" ~char *killzero(char *res,float result)' l( k8 o  I7 m
{
& \; t  B! b8 b3 { int i;) x6 Q' G  Z  b% z

- n8 q1 z6 c$ I  m4 z sprintf(res,"%f",result);
1 |6 }7 ?0 f( ]. R8 L. i6 ?$ `# _7 O i=(int)strlen(res)-1;
7 s3 l/ B8 \# G- p4 d9 F% _  D, t! P while(i&&res=='0')
5 G1 {6 R$ N/ U {
5 T2 q0 Q$ [) n6 t6 m/ I" J       res='\0';: |6 Y; R* V' {( P8 }
      i--;; b# l( H% d8 V9 T; [/ n+ K
}
) v1 k. R1 @* p$ U if(res=='.')
, P& R* w; g8 P1 e! ^% Z( _       res='\0';5 ^/ J- Y: H8 e- c) P6 p
return res;
$ |% y: f5 E3 D& N* k! U, ?. G% ?}- G& Y6 Z+ r  t  a

& B3 \1 z, N- [7 g  r- T" Aint main()( v% o$ T% ]# `7 o. T5 `" N
{
* r% K7 @) ?7 Y: Z! A/ w) e2 a char ch;: e* ~3 v: n' N" u
char res[64];9 c1 J& m0 @" R8 l* D7 p, X
float result;7 {$ H% H  ~9 Q" h  ~
while(1)
5 C5 f# _) @% a9 B- g {, E0 y+ R) M  L; g
      result=compute();# t* w; a- f, t0 p* t( d  I  ?
      printf("\nThe result is:%s\n",killzero(res,result));
) Y! _: J+ n1 F1 _% P       printf("Do you want to continue(y/n)?:") ;
1 V9 I8 I' I; |. p& {0 Q2 j) m( R, y       ch=getch();1 Q0 d/ Q, D" m5 j" z3 m) F* `
      putchar(ch);8 t+ Q! G# s) g7 m5 V7 H
      if(ch=='n'||ch=='N'): S0 w% Y2 K# j9 x
         break;
6 l6 n) j4 D+ m       else1 K- u0 A# G) I8 J: S0 _" `, U
         system("cls");) W1 J/ [* M% {( e
}' ^6 t% G; ~2 Z' }
return 0;' a3 a3 f4 Y  S8 D+ ]1 y" h6 j
}

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

返回列表

C语言表达式计算器

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

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