C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>+ i, G1 X: q4 {& Y' [+ {- C
#include <stdlib.h>
#include <string.h>/ g5 O1 {! P, E( v* v
#include <conio.h>! H5 l) `* z: h; q4 `
#include <malloc.h>
( m" R8 F1 z3 R% {4 U: D
#define STACK_SIZE 1005 Z6 u7 b+ d8 x! Y
#define APPEND_SIZE 10

struct SNode{, k0 ^2 }9 p8 f. x5 n: `
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/  b7 g# K0 `/ @
};

struct Stack{
SNode *top;
SNode *base;' D5 C, K1 ~  w# z
int size;
};+ B9 C6 |/ S5 f, D( H

/*栈操作函数*/6 [, j( _# ?* O: _4 {- m: \2 |
int InitStack(Stack &S); /*创建栈*/3 V' c/ I+ F0 G* ^0 ^
int DestroyStack(Stack &S); /*销毁栈*/1 J2 D2 S/ t' q6 |! X; [
int ClearStack(Stack &S); /*清空栈*// ], [( C1 r' e/ g: s
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/( C( O4 p# ?5 S2 i4 h* A4 f
int Push(Stack &S,SNode e); /*将结点e压入栈*/$ ?8 Y5 ^2 x5 M  X9 c
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
1 J% Z1 |1 x) d+ w, f' F# x: x& n, U
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/9 b$ H! Y$ `' a, t9 v5 S
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/* M6 p3 m7 b6 f% |
float compute(); /*表达式结算器主函数*/* x9 y! p6 ]9 w1 [1 j: t
char *killzero(float result); /*去掉结果后面的0*/
4 n" P" f% `' c1 U3 N
int InitStack(Stack &S)" Y  e/ i9 K# n
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));, Y6 c0 c( g7 {7 J  S6 _7 h. Y
if(S.base==NULL). N3 S; k; a9 \1 ?. f0 d
{! o7 G9 t8 e8 @/ e$ [
      printf("动态分配内存失败!");
      return -1;. @. p; {3 }. y
}
S.top=S.base;9 E0 I, l, v3 p0 B2 }1 \
S.size=STACK_SIZE;7 I- n* ^9 P+ |
return 0;, {; O9 o" c$ Y$ o
}: G5 I6 V" m& z- U

int DestroyStack(Stack &S)0 ]1 I1 u% f. J3 I$ A5 b5 D
{- ^) f. Q: r7 E5 L) ?) e
free(S.base);
return 0;
}) w7 S. E4 z" M0 {

int ClearStack(Stack &S)" ]* l% y# }5 m: O7 ]  \
{
S.top=S.base;
return 0;6 R; S% e6 }: U$ R6 w" F( C
}- B4 N: z' F' |3 U/ [: p& e& G

int GetTop(Stack S,SNode &e)4 N8 N7 l: a  T; W9 S9 l( g
{* g. d  O: O4 r% v' N
if(S.top==S.base)2 g- d( K8 u7 ~6 g* [  Z  {' Q5 W# B7 c
{9 U6 q% `1 M' Q2 k$ ]/ O
      printf("栈以为空!");% {) s: I9 z6 k' @/ K' X3 |
      return -1;
}
e=*(S.top-1);
return 0;
}- N( S% O0 i# K% u1 m* ]  a7 a: C, ]# R

int Push(Stack &S,SNode e)
{1 V) y( b6 G& `$ V' s' H9 M
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));# L$ C! D5 z7 X4 ^7 j3 m( f
      if(S.base==NULL)9 P% f5 ~6 p3 i* X' J) Z9 c1 ]/ b
      {
         printf("动态分配内存失败!");
         return -1;
      }% i* v* s4 f2 S9 v- W
      S.top=S.base+S.size;) G- R& d! g- g$ b- t9 L
      S.size+=APPEND_SIZE;
}# V  A0 d' ^9 U9 @
*S.top=e;
S.top++;
return 0;7 z6 i7 X" c. I5 I5 [1 P
}
" U* F, h6 s( c, G$ W* v4 f5 R
int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{2 k9 R( T6 Q) [+ Q1 `- E
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);
S.top--;7 s; t( M0 [8 d$ z
return 0;
}, B6 T7 E6 c9 Z, f
$ h' C. L, k& y/ ?/ B7 g
char get_precede(char s,char c)
{7 t7 f- P5 y; T$ m
switch(s)
{* W2 Z$ c4 e& p" v  g
      case '+':                % C+ s% c  t. X4 x
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '<';. o* p6 X( O- _% D' Z$ @
         else if(c=='(')
               return '<';
         else if(c==')')# l) I# m5 q# P
               return '>';
         else * O" @% B2 M4 ~" V: Z: y  `
               return '>';
      case '*':
      case '/':  s2 _* T* Z0 O, |% z$ P+ R
         if(c=='+'||c=='-')
               return '>';3 ~: m. S* I' p: e, H
         else if(c=='*'||c=='/')' z4 f% s* O4 d3 @/ |' Y
               return '>';
         else if(c=='(')) f% w3 y6 h9 M+ y* J. D
               return '<';6 n; p% v" Q) ?1 m- \2 S* J% M1 \0 Z
         else if(c==')')
               return '>';! l+ C; B& v8 @9 W( H
         else4 U* b& A9 S: H) d
               return '>';& g+ i  ?! I5 N7 i, [) @& |
      case '(':
         if(c=='+'||c=='-')& [5 O8 S* s. ], @# F
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';5 Q/ Z% I  \" H2 o8 k( x( r0 I
         else if(c==')')
               return '=';+ `# m' j7 A( s; g% D
         else
               return 'E';
      case ')':3 ^! C- i, a3 p! W- C7 S' z
         if(c=='+'||c=='-')
               return '>';- s) \/ L, V, H' {8 ]! D  ^  N0 d
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')
               return 'E';1 u* ?; y; H3 _  [
         else if(c==')')
               return '>';
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')$ P: \2 k& N; B/ _
               return '<';& a: u" f2 h0 }
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';7 |& N. E8 p& U, O
         else if(c==')')
               return 'E';* d# i! K" i; v4 t# A: ~
         else$ T+ A( w6 A. Z$ S4 _" q3 `
               return '=';: I! k# e( V" L, O
      default:# K. s  ?3 U4 L/ I! n. h# S! C' y
         break;( o6 y7 ?, Y9 k" d8 x
}
return 0; 7 b% f1 a3 s; ?# J0 e1 R
}

int isOpr(char c)$ K" i" {2 S( Z6 D
{9 x( y7 D, w, U; X& r! z7 R
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;# x9 L& ~4 l% _0 K4 o# N: _
else 7 T. K: a* x. J; y/ @& e9 \
      return 1;: F3 X- v! t5 z' L  n  y! P# |7 z' [+ X
}

float operate(float x, char opr, float y)
{" i# u" a5 x$ ^% u- b5 H
float result;5 x+ M9 e/ _2 b8 h. l5 `3 s0 g
switch (opr)
{& O) i8 a  V( ]5 A
      case '+':
         result = x + y;& J2 a, g; x2 b$ n' p
         break;
      case '-':
         result = x - y;
         break;3 w& y; n( o* y+ [+ e6 h
      case '*': , W) ~- h: N% m9 p9 u# ]
         result = x * y;, |7 O2 }) j' L% ~) D
         break;4 ^5 s! Y2 O( m$ b- _# y' w$ |6 h3 U
      case '/': % U6 c% n$ A1 `) ^: W' s5 l
         if (y == 0)
         {
            printf("Divided by zero!\n");! O. D9 A+ d- E6 a2 c
            return 0;( T5 \/ ]2 o4 D' e3 V
         }- X  V# l9 v+ A% y
         else! ~9 ]2 U# u9 `" a2 u  ]6 x$ L
         {6 a6 t1 u3 l! I! |5 H# W( e8 J; S
               result = x / y;" s/ m+ r4 q. V+ H! L3 p. z
               break;- T) O% T" k! `2 w& M5 O* W
         }3 i3 x7 G8 s7 C( Z0 y" C% W* U( z
   default: " Z% d( y( Q# o, e
         printf("Bad Input.\n");
         return 0;
}( H& M( i9 q* \6 K! H
return result;% t. C/ C. c* p/ M  _
}
" D/ W# v% ]  G
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{5 ]( ]4 j& q" x
Stack optr,opnd;, g0 x, V! A  f: B: t
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;+ W1 f9 r- l6 P/ q
char c;
char buf[16];
int i=0;3 T6 P) N9 {, j5 ?4 I2 q

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");
      & A; _1 p, Z. D+ f7 b
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);. C% p+ i; p8 ]4 ^3 N9 e, W
c=getchar();
while(c!='='||opr_top.ch!='#')
{, k: b" Q8 i# e
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {; n  n5 ^$ L! P
         buf=c;  P. y. f. ^+ O. q: a, t
         i++;
' j0 L( j7 `- H          c=getchar();+ I4 X6 C7 t% p5 |2 I
      }9 {$ r* t; G0 y: Z- u# N
      else /*是运算符*/
$ c- E' Q3 g- y; Y1 P       {
& @) G; x7 J8 q          buf='\0';0 x4 G0 }- R) P4 ^- t3 Q
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
1 C) z4 v: N6 Q          {0 E2 U( P6 j/ R
               opn_in.data=(float)atof(buf);
- R0 f" {. u6 I0 e* o# `3 N. D% s                Push(opnd,opn_in);
$ z0 t1 _+ S0 i! ^: ?3 Q! C                printf("opnd入栈:[%f]\n",opn_in.data);
0 h2 T5 U0 F- f1 M                i=0;
2 B/ g2 W3 V1 M+ i9 H: X                memset(buf,0,sizeof(buf));5 i$ P" Y; E* m& ?2 Z+ \3 @- R4 P
         }# R5 f  k* C$ P" j
         opr_in.ch=c;( |8 ^9 k, g! h- H0 s$ p9 M; q
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/6 A7 @. t: g4 p: u& Q3 o  r
         {
7 B% s7 R. Q$ _# e1 b, ]2 C/ q             case '<': /*优先级小于栈顶结点,则运算符入栈*/
4 f0 `& k+ p6 E+ V: U1 r' R                   Push(optr,opr_in);. f7 s$ P# I4 x; S: e
                  printf("optr入栈:[%c]\n",opr_in.ch);
" t& A9 t1 b0 d0 H  g2 v                   c=getchar();$ ?) O: H$ V: Q( {. q0 |
                  break;- N+ v6 E. @' v# l% v
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
2 ^- j0 j7 F  t- Z- |: v! s                   Pop(optr,e);
1 s- N1 b+ D- B9 z0 a                   printf("optr出栈:去掉括号\n");' X( n, K/ [) T4 g5 x  A) [6 v
                  c=getchar();
2 ?; b3 u  @9 k& o+ z7 Y                   break;
" \6 v) N  u0 S3 B  K             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/5 _3 ?1 {2 z+ ]" @4 \. ?
                  Pop(optr,opr_t);
: d  g/ E: Y" ?0 {0 H                   printf("optr出栈:[%c]\n",opr_t.ch);
  C6 g$ p4 V# M- a1 V( S' U2 M                   if(Pop(opnd,b)<0)
0 E- `/ h+ t3 \8 K4 F: [- v                   {
4 H- [! j# A. N/ l8 f                      printf("Bad Input!\n");# @) K5 t  j$ O' S
                     fflush(stdin);
$ b2 n+ ^9 R, A" i7 e& z& B0 s                      return -1;
5 J" U1 }2 g0 f! H2 U                   }
0 ]! Z7 c3 P" V: B6 |' b5 o- u( F                   printf("opnd出栈:[%f]\n",b.data);! {) L0 f- Y0 l! b3 m
                  if(Pop(opnd,a)<0)
. a! C. O$ v- ?! X% T, |: k                   {
! }3 C! @% ?. l; G1 k! E5 s2 ?                      printf("Bad Input!\n");
* }4 |4 R4 w* K. q6 g3 g- K1 _% v                      fflush(stdin);/ c8 D. p! Q% L, ?- n) N/ Q+ T
                     return -1;
* i, o* u" q1 N( ~                   }
+ N$ l+ J  s8 N                   printf("opnd出栈:[%f]\n",a.data);5 o6 A& Q- y! C0 p- \
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
6 D: q( h( i/ K1 A                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/% f4 H. R" g4 ?, m5 ^9 p- e
                  printf("结果入栈:[%f]\n",opn_tmp.data);
6 l2 M& s& n' ~4 x  c  o7 @8 y                   break;
# ^1 \7 H- o  a  e; n% v/ z          }! E, K; x9 ]* O3 c
      }
- `9 y/ O' Y1 c& E8 p' O: u4 [       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ! ^2 H! C) C( {
}
8 E1 j4 c) z  P7 X# a GetTop(opnd,opn_tmp);
; a1 k- _0 c, }: R' u' D1 |1 D DestroyStack(optr);
- A' K/ w, f8 e6 |* W DestroyStack(opnd);
1 t: ~* a7 S6 l return opn_tmp.data;
) t, x6 B  H+ [}

9 i- k% Y  s- L/ pchar *killzero(char *res,float result)  J$ z+ X) }8 E+ ~
{
' k! ]6 h$ c. Z8 ?5 W* }/ ?9 W int i;1 m. ~# L, q2 T3 x; s# ?, h
7 O, u! H! o5 ?6 K+ E
sprintf(res,"%f",result);
  `/ H" d4 e3 E& ] i=(int)strlen(res)-1;
: [+ I  s3 z% B+ g while(i&&res=='0')6 S3 \5 p$ D( s: ?, V$ f: z
{
* q5 q- D! M5 @; x$ E% b       res='\0';4 ~3 q& p9 o! e: D1 g% L
      i--;
+ F) b5 X& Y' B. i0 i) s/ P }
, U5 G  m  R) l& ] if(res=='.')& ?+ E9 |. \- E4 k, L) t! U  A
      res='\0';% r: ~2 C1 n+ J/ ?
return res;
- J1 f% Q+ F. M3 @2 u}% z* f4 c0 q: Q  ^  `1 M" D& ^

8 ^1 c+ }' h9 C" ~( d0 C6 i, Uint main()6 [- G1 z! _# T5 e! j6 u2 f  ]
{
, g; K% B% O9 } char ch;
. H+ Y! c/ j! O9 u1 B( n char res[64];
* X7 e' P: `. j$ f" w float result;
2 |$ |; F9 \+ L8 E5 c while(1): t" l' p& m$ @  r
{, l, T* b7 J$ Q$ W- T
      result=compute();# \; n- \% t& Y) I+ ]
      printf("\nThe result is:%s\n",killzero(res,result));
2 D$ W1 A8 \( D/ {       printf("Do you want to continue(y/n)?:") ;/ V8 y$ R3 Q3 q! G) v: \0 `. z
      ch=getch();
7 _+ q+ Q; Z. ?/ J1 [  `$ U7 R/ r       putchar(ch);
' Z* j1 }8 a7 U) `, s9 S       if(ch=='n'||ch=='N')
* O' R: B/ y6 L2 l          break;# h! f$ E1 Z) F. N5 \- i  E+ J
      else
# y5 `$ E7 ~1 @          system("cls");8 x. z9 z* ?+ J# u
}
( O: u" D0 Z$ S; p- ~* b  T. N return 0;9 Q5 k+ |$ J8 v5 q; H- {5 N% S! C
}
' N, z$ ]$ U* u% @* H; E9 Y
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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