C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=; c; K+ O# Y9 y3 K  s! [! ~' g& R& {
/**************表达式计算器************/9 `  _# g$ W) ]5 u. X6 \/ T& g6 S
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>
6 Y8 c! S6 Y! y5 r8 P5 s* B) k4 I
#define STACK_SIZE 100
#define APPEND_SIZE 10/ U4 l6 U! O3 k$ F- |: _% x

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/; }9 {; ~4 [7 C: A' J
};0 m- q) O! S; _1 U
% T0 s0 H' T/ D
struct Stack{
SNode *top;7 k0 S+ n4 `- i: k
SNode *base;
int size;7 V0 ]( A% @. X; J6 Z$ H
};! u# Y$ _( r1 A7 c9 V* K

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/# N) m( B6 E  d$ X- E" B0 J
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/* k# _  C# E9 u* y
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/. `0 E# J8 U4 I8 g6 \
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
( t0 d0 ^" p1 f; A; H- N  @
/*表达式计算器相关函数*/: d, n9 j* W( i' x/ n- }2 e9 B+ O
char get_precede(char s,char c); /*判断运算符s和c的优先级*/  J$ [* n7 I( n( d7 [3 b. a
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*// F$ v/ I5 V3 v( A/ D6 e
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/: a- @* R3 j* b1 m% z5 @
float compute(); /*表达式结算器主函数*/3 M) a, W2 `; s: \3 y
char *killzero(float result); /*去掉结果后面的0*/ & z& a! ~6 \# \) h

int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));4 V6 P5 i% c8 \3 P% g
if(S.base==NULL)% M; r+ X# L* I- Q: R7 z
{8 Y0 z# R- X! V
      printf("动态分配内存失败!");) O0 u" T& l9 p, X% T
      return -1;9 `; y; b' H$ H( w6 i% C% ?+ F- U# }: H
}: V$ c$ v$ j3 w  M' f# r) k' ^3 P
S.top=S.base;" A$ V1 Q2 A1 o' o& b3 {, d' U
S.size=STACK_SIZE;
return 0;. `  ~/ P+ t' z3 q% Y
}

int DestroyStack(Stack &S)! j, m6 ~7 V) ?# P# q$ P
{. |3 M- [" t8 g4 O$ ]
free(S.base);8 x% o( [. g1 m6 \# Q
return 0;
}4 N' r* b3 t5 C- i) y7 c
2 d8 V, \) p7 g) R, L4 |- J
int ClearStack(Stack &S)
{) Y: O( Z) @- ]5 I
S.top=S.base;0 a( I- G) w* t- P& P' t9 G
return 0;5 f0 p9 K6 L( a0 t3 ]) \
}( j- k+ k% }. W+ n4 _
* p. V! w1 }8 o1 U7 n
int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)( }0 n" T1 r8 p
{* i, |' M. m3 n8 n( z
      printf("栈以为空!");
      return -1;% z7 j; r% c4 X1 b4 N# a5 R; b/ [
}
e=*(S.top-1);
return 0;6 X: j( j; W4 {% O
}7 u2 L6 i- {; }
; b5 _5 F  f' v) Z3 t. E
int Push(Stack &S,SNode e)7 F" c6 K2 T  Q; n
{0 v& t. A) K5 c" g2 V. ^
if(S.top-S.base>=S.size)! ~" ^) X6 J" G2 S; h
{! I" |( y" @$ X9 P
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL): F, l3 ]8 s) u1 c' b
      {
         printf("动态分配内存失败!");
         return -1;
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;  d$ M; x: r) q  t/ X
}
*S.top=e;* I8 @# r' M* J  Q; f. X+ P
S.top++;
return 0;! p$ m/ W' W+ ~1 s5 ?6 q0 P# g* A6 U/ \
}
% T* ?: ]( t, g' k4 Z
int Pop(Stack &S,SNode &e)  }5 B1 }9 N, c* V, X; k- I: r9 U; d
{2 y5 M) D% ~4 v  s* E. W
if(S.top==S.base)# X' {, z- m) b1 T
{
      printf("栈为空!");! V$ `& n- V$ j/ `
      return -1;- l% L% l- o7 L8 |$ X
}
e=*(S.top-1);0 m; h  z! z  ^$ O# C5 O
S.top--;3 A! B2 [& t; l1 `
return 0;: \1 ^( n* k* ]# s+ s
}

char get_precede(char s,char c); Y3 {& ]: E7 O$ M: O0 L
{4 b" ~/ j" I% \" b/ }6 b; ?% P. F
switch(s)0 c, J6 @+ y  I; x0 T; C( q
{
      case '+':                2 S1 X+ ?7 O" u1 D7 `0 Q7 n
      case '-':
         if(c=='+'||c=='-')9 D6 s  G, x! ]9 Z( ]( m
               return '>';
         else if(c=='*'||c=='/')
               return '<';, b9 V0 ]) m5 X
         else if(c=='(')# t9 I! O# |$ t) G( ?
               return '<';
         else if(c==')')
               return '>';$ n% M. W, s% L7 j& K$ }9 D
         else
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')  f3 Q4 R( ~0 q) W& X8 I& O: I+ l
               return '>';
         else if(c=='*'||c=='/')2 c, P5 W2 b! ?
               return '>';% E7 _4 X: J1 d2 u
         else if(c=='(')) h; l5 Q. X3 \; P" Y
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';
      case '(':# T5 X- ~% m5 \: {4 b* x4 U
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';% r/ v. ^7 D: J( m* Q, a3 @
         else if(c==')')- [& {; m; I# o4 r+ k
               return '=';
         else$ d% Q" C2 L  j! ]; Y* m3 w8 l
               return 'E';4 Y' }2 c  l6 k. u
      case ')':
         if(c=='+'||c=='-')
               return '>';+ s2 H1 W) Z  _0 P, E
         else if(c=='*'||c=='/')
               return '>';% `( T; h- Z6 l1 _1 c* }5 U
         else if(c=='(')
               return 'E';& p; @: k9 {3 S2 W1 r% X: A
         else if(c==')')
               return '>';
         else
               return '>';
      case '#':: t. N" ?: v" l8 t, S
         if(c=='+'||c=='-')) @5 q! S( j) F4 b# U8 h
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='('); V$ \! Z/ e( X% J
               return '<';+ j5 E1 h+ b# M/ E
         else if(c==')')+ ~/ g. H) a; F$ g/ \' r
               return 'E';
         else
               return '=';
      default:
         break;3 D; k. i/ U; C9 L' v7 w" N. P
}
return 0;
}1 q9 R0 b- F: B' A% T: {! h! W8 t# n" W

int isOpr(char c)
{! y! F" t& o' `( @- ~4 a
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')7 G: M" E% m; S  j$ i& H" |0 `
      return 0;
else / m% ^! R  p! C+ K* N5 M
      return 1;$ y! G& P1 ~$ i. d4 O/ r
}
& [. A0 K# |  `! P4 E
float operate(float x, char opr, float y)9 m( R) t' n" b3 [+ G) d
{$ p5 i2 c2 h6 X6 m& V/ g4 u$ W5 V
float result;% W4 j; k- o, D, s4 I7 j4 j
switch (opr)
{5 ]! [7 _2 x; c+ j/ G, m
      case '+': 7 X- W, f7 c: z0 C# G; n0 K$ n
         result = x + y;
         break;) X3 \6 N4 L8 n1 v# P
      case '-':
         result = x - y;
         break;
      case '*': " t& o. {. s9 Y/ R8 h
         result = x * y;7 S- f& J3 h5 E! M
         break;
      case '/': ( o; q6 o7 m& Q2 J$ Z
         if (y == 0)
         {: O1 z5 _4 s: _0 w' ~
            printf("Divided by zero!\n");7 M% |+ u; L0 y7 T( V
            return 0;: x, Z/ d8 e3 L4 E4 D
         }0 R- M" K: i! Y7 V! O7 ]  h6 ~
         else/ b0 C. N3 D) u% N' l+ a4 [
         {
               result = x / y;
               break;5 v. H" O; I; t' Z5 I* R
         }7 k% K. G& q& Y" k4 ^! U+ p
   default: 9 I. _: d) l9 W# O
         printf("Bad Input.\n");   w* \3 ]' x, k- j" K" c, }! ?5 Y
         return 0;
}
return result;: Y7 @! x0 j& W, z+ H
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;5 I; @0 @2 G, z' b- I
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;5 z" r8 B6 A( q7 S& i7 J& p1 o
char c;
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/1 W  l/ z8 u* k7 y
InitStack(opnd); /*用于寄存操作数和计算结果*/: |+ l* _# o1 x; E/ Q) v
memset(buf,0,sizeof(buf));0 X( D. M. M, D  J8 [) ]6 M* h
# d4 u4 V# Y* x7 z% C
printf("Enter your expression:");
      ' M8 h. `0 @- i
opr_in.ch='#';* V. U" i1 @: F* i
Push(optr,opr_in); /*'#'入栈*/. u0 }  a! p3 N: \
GetTop(optr,opr_top);
c=getchar();/ a  |/ e  q) Y, [# i8 ~
while(c!='='||opr_top.ch!='#')
{, S% w8 `0 {) T- L
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/5 B3 n" ^2 ]' x; `( m
      {$ v) h, M  Q. ?$ P& B# D9 F: q
         buf=c;
2 r; I! ?  `- P7 G2 k          i++;
         c=getchar();
5 m6 i  \: u+ {2 ^- T       }
* M. ~0 _2 r- @# Z       else /*是运算符*/  ~" ?8 a8 _4 X9 H" @8 L8 o
      {
2 o; L. O$ a, l4 c$ M7 v- T          buf='\0';
, X8 X- a+ `+ ~* P2 l$ V# r          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/+ m" c. y# U4 G& `
         {
  o7 x: Z4 a; r" I, Q7 f                opn_in.data=(float)atof(buf);
! t) e- s3 c* {, _                Push(opnd,opn_in);. L+ U3 A+ v# v0 G: l
               printf("opnd入栈:[%f]\n",opn_in.data);+ e; G4 Y( k9 q6 k% |0 x
               i=0;- R+ n  u6 ^: d
               memset(buf,0,sizeof(buf));+ d: U% K4 @3 U* k: |- o
         }
+ O) O/ y: R5 v* N          opr_in.ch=c;
+ a3 {( Q! U( v! O, P          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
1 o$ D+ c  s. m4 f- R3 b8 t          {
' a$ K- ?8 R  x# N: X             case '<': /*优先级小于栈顶结点,则运算符入栈*/- |6 U* g/ h9 r
                  Push(optr,opr_in);! y7 ~! N& v9 Y: i7 @* T$ m+ m
                  printf("optr入栈:[%c]\n",opr_in.ch);- _4 s% }- W; c: K9 B
                  c=getchar();& _- G* j- p( e) H- R! y2 K
                  break;
% t/ ^5 L0 k' Z" g4 ?2 X) s8 o8 _             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/: O) J4 u* k9 y
                  Pop(optr,e);
# d/ C; l1 h7 k/ k9 w% W& S                   printf("optr出栈:去掉括号\n");
" B( _0 x& T& N2 O  q: C$ O0 j                   c=getchar();( n, H+ n# [7 p& d* r  Y3 z3 ^; n1 J
                  break;3 [* ^0 W9 d6 P6 _- [2 i
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
9 s! O" ~( j: g0 g                   Pop(optr,opr_t);
* }+ v: V! t, J4 Y) L& n                   printf("optr出栈:[%c]\n",opr_t.ch);
0 G' x9 P$ r* ~! z                   if(Pop(opnd,b)<0)
/ }0 L, D# E- `" R7 R                   {6 n  s0 w& W7 b: q* E
                     printf("Bad Input!\n");& G' ~' w) i# b7 t5 w  [
                     fflush(stdin);% u; n+ z1 e4 y- w
                     return -1;
9 u2 T, F. y. d! u1 W                   }/ F! Y% ?# s% h7 A7 R& [% E
                  printf("opnd出栈:[%f]\n",b.data);
1 [; C) N6 e! |                   if(Pop(opnd,a)<0)2 l6 _: t; |9 D) u! q5 Y/ D
                  {
+ W+ ^8 j# C; c                      printf("Bad Input!\n");
" u, f9 }4 U( X                      fflush(stdin);2 c$ q$ G  F. S: d' Y
                     return -1;
: I' ]$ B; J/ P( j( C- V& A- J                   }
" k) d( @& Y" e                   printf("opnd出栈:[%f]\n",a.data);* v, V, P# C  R' a# s% `
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
4 I' \5 r6 y& }' a: C) r; H) b                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/: X0 R, Q- u  c8 Y- F" ?$ ?
                  printf("结果入栈:[%f]\n",opn_tmp.data);
: T9 `* C5 F' p, ~                   break;
0 i0 c( o8 D% M8 A# V          }
1 e: l% e2 a( g/ b0 i       }
  C2 O" e- M5 R6 N1 e# |! d" [; @       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ! b2 I2 \9 I/ g* i9 f7 c
}/ I: ]% r- r- x
GetTop(opnd,opn_tmp);3 u% _" @  S2 `
DestroyStack(optr);
; a1 {3 [$ n  l$ H/ f; | DestroyStack(opnd);# c5 |$ \. N/ S, c& I  h) ~
return opn_tmp.data;
* c' t* h( A# d5 l5 U}. A8 r0 `: f$ D4 E

& [4 ^! ^& V3 A/ d; Achar *killzero(char *res,float result)
7 _5 N/ r9 }7 Q+ {% d1 Y. w& H4 I* l{
1 x% c! c2 \; m3 c3 f5 g int i;4 V3 {& M, H- q+ \, l& U
' y* ~9 r, B1 S) R! |) q; ?
sprintf(res,"%f",result);
$ C  l. k: C9 i( N% n i=(int)strlen(res)-1;
5 ?' Y" q' A  @5 _( i# W: |& i while(i&&res=='0')7 L& B5 Z) C& k
{! ?( r" Y2 Q: V- H! x% R+ U7 i
      res='\0';
3 c9 ?; q5 O9 [* j' C       i--;
! A  O. Y0 T+ s0 u- z }
1 H/ }. b/ \) u: y$ h% @/ X! ? if(res=='.')# U+ Y  _4 O9 b3 G4 X) s
      res='\0';  }4 \& O" v3 y5 j# l4 H2 [9 ]
return res;
. A, a: Q+ c/ _7 ?. T}
/ I. n" b2 [0 L' `/ L2 @- _- H
int main()
: ?$ v, s- Q" l: b3 F{4 @, G( a# |  m; g* a5 |
char ch;6 u# Q8 x# v! ]( D5 x
char res[64];  H0 v6 S% Y7 p8 Y+ K
float result;/ B' N0 k$ `+ g0 O6 m/ y
while(1)
: Y1 v; X- E" k. i' g {
" l. ~. B; b% c2 R' @# ]       result=compute();
. m7 X  \# C. }/ V: ]       printf("\nThe result is:%s\n",killzero(res,result));0 z+ @4 q8 h7 p& H# B
      printf("Do you want to continue(y/n)?:") ;
5 c+ O& \0 i# A- d1 v/ @/ u1 Z. d       ch=getch();2 Y0 g* d3 v: T9 c, ]
      putchar(ch);
. Q: d2 u- ]* Z" n+ b* }       if(ch=='n'||ch=='N')3 T4 {( G/ X+ h( B6 b7 L5 c
         break;" |  i9 ?' ~/ A6 q8 s1 i( s
      else
) c* M( p, ]' W- m- r! N, c          system("cls");
7 k' q3 l0 J+ n; T( \1 m- D8 f }
6 u$ i) H, U+ B) t% ^: [ return 0;
3 u# X* W$ F) r}% m! l; f. {  w$ b. c0 Z8 x
5 S! ?2 C/ s! S  R& a- W$ |
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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