C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.4 F1 V2 g, j3 R! }# r" y" g  n
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/4 a9 t! L6 x% u/ e, h
#include <stdio.h>3 \5 o  P0 ?6 k; T  l- u0 q
#include <stdlib.h>
#include <string.h>
#include <conio.h>6 N( y) D; D. l! \
#include <malloc.h>: F) Z9 L7 u  @# k, b. m& o  ^

#define STACK_SIZE 100
#define APPEND_SIZE 10( G/ Q  C0 m6 X2 @/ Q9 s7 l

struct SNode{
float data; /*存放操作数或者计算结果*/. I- `& P9 I& V! x9 t+ U7 x
char ch; /*存放运算符*// c- y5 S5 h# P& H4 p; ~
};

struct Stack{
SNode *top;
SNode *base;
int size;" O8 `6 f4 R6 p6 @# }: |( [( K
};/ _  E/ r, ^* E4 n0 f
! V  F6 B2 z6 r! G* |0 U, {  m$ i
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/! z" r# D/ j3 A2 Y  o6 @
int DestroyStack(Stack &S); /*销毁栈*/4 P: c" r& U+ x/ b' |% C# M; c
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/% M9 d2 E1 i& F+ X" m4 u" G
int Push(Stack &S,SNode e); /*将结点e压入栈*/- t0 h7 i; u) C& Y# K  [+ g6 |
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
3 g0 ~) a7 z: S7 U* i- L$ P3 F; [
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/+ v) i8 A0 _, T$ z7 E4 a
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/8 e, J# Q7 B) o+ @/ E7 L
float compute(); /*表达式结算器主函数*/" J; e6 Z5 C* S
char *killzero(float result); /*去掉结果后面的0*/ 9 `9 z" g2 `0 e. `, `( Y( b

int InitStack(Stack &S)# I: U; F! L4 x
{- u" O$ e6 C8 [3 a4 ?
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL); l3 {: J) m+ L9 _' `# a$ e0 m
{' h, @0 T0 N3 @* p7 g) n8 }1 \
      printf("动态分配内存失败!");
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;$ {3 {6 b1 q6 A9 L$ z, {
}
3 @: s% k% \' E& h7 B( T' [
int DestroyStack(Stack &S)- y- }5 o% z9 ^; u8 p- E: Y* q
{
free(S.base);6 L5 ^6 h: p  M
return 0;$ u  Z/ ?7 v7 E. h9 a2 l
}& E/ c$ A1 `% b1 _7 n
8 t0 P' U9 G1 Y
int ClearStack(Stack &S)3 i; V( }7 R; d
{2 z! }/ l+ H1 e' L: H6 p4 ?
S.top=S.base;& D( l+ ?4 J8 k/ c. G5 w
return 0;
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)" M( P  m- |9 z, S+ T; Z  e
{& e, ]+ K) i, [2 Y9 ]! g
      printf("栈以为空!");
      return -1;7 B) E5 @9 J2 f9 J
}
e=*(S.top-1);
return 0;) h+ [) v: r: l' c" U
}/ l3 g& Q; |+ w* {# G% h$ e0 ?
$ x; [1 l( b4 w
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size), r( [2 E: `  [
{  Z* D4 S0 ~" B6 h6 c5 q' ^% i3 W
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }9 z  E/ z7 P9 T1 y9 m3 L3 a
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;* F- C6 F0 v; U6 N0 G( z
}
*S.top=e;
S.top++;
return 0;
}
; e0 W8 I0 s% L- j' S: q5 D
int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{* O1 s$ b  I2 o  j) G
      printf("栈为空!");) z! y9 @2 I8 `
      return -1;
}
e=*(S.top-1);$ V) ]1 n6 l. _' S+ P% y2 Q( k' D, M
S.top--;- t! v% ~: W9 X& l* O+ c
return 0;0 E. x7 |1 N- E) h0 s
}. g& i+ C* k% k0 s% R

char get_precede(char s,char c)
{
switch(s)
{8 t9 F! ?9 ]  x- Z! g  m
      case '+':
      case '-':5 X6 ?& E6 {6 o$ Q1 i7 T, N
         if(c=='+'||c=='-')
               return '>';2 Q$ f% ^5 A2 i6 `" f
         else if(c=='*'||c=='/')( I! h, N/ j1 L" o3 @# Z6 R+ n$ n' U, W
               return '<';
         else if(c=='(')0 z3 {5 L* ~4 S
               return '<';
         else if(c==')')
               return '>';- K" l% m1 u, A6 x9 b' x2 y* @# M
         else
               return '>';
      case '*':
      case '/':" ~1 ^1 Z' u7 k" P6 m- A
         if(c=='+'||c=='-')" j( @7 D; n% n1 w. k& x! p2 ~6 E' `  j5 R
               return '>';
         else if(c=='*'||c=='/')1 M7 w% ~, t& r7 @1 X
               return '>';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';8 O! _: p5 ?- E5 e/ W$ w" C
      case '(':& k9 J2 _) N% D! K! j* P
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')8 e+ }( L" a$ h- }
               return '<';
         else if(c=='(')* ]) U$ H' \4 _% O! @2 [
               return '<';
         else if(c==')')) A7 X5 H. C5 R& Y' n
               return '=';
         else! ^2 E: Z: W1 ~6 f( _
               return 'E';4 I/ ~* U  k; B6 O& D7 s/ \: S9 }
      case ')':
         if(c=='+'||c=='-')
               return '>';/ @& |. C* Y, \3 s% ~
         else if(c=='*'||c=='/')
               return '>';. k1 X" D/ E; D0 j7 l; g
         else if(c=='(')
               return 'E';
         else if(c==')')# D' r$ _6 V7 ^; E8 [! s2 a+ p% x0 t
               return '>';/ \, Y* x& Q, [, v7 L/ q
         else
               return '>';( Z; d  B' p5 y. a& p
      case '#':
         if(c=='+'||c=='-')" q  P! c) z! q$ o
               return '<';7 y. t: o1 P! L  p, b( G
         else if(c=='*'||c=='/')0 o1 n8 H" ]" p) R" Q
               return '<';
         else if(c=='('): Z( a" h3 ^- P
               return '<';; ?+ z" D& z5 s/ s% n+ ~/ P! B
         else if(c==')')
               return 'E';
         else8 p% ?$ V  Y5 i; Z
               return '=';
      default:
         break;) p. u: Z' p4 O* j! M
}
return 0;
}: a: M$ S2 z0 u1 ^
2 L$ h, h% J, N# [
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')2 p4 Y$ o) T. G/ Y# v; v
      return 0;
else & }5 q; [) }6 |
      return 1;
}

float operate(float x, char opr, float y)
{
float result;: z) b7 Q; N; C0 K( B* F; a) \
switch (opr)
{
      case '+': % w+ r. p0 M+ Q, L+ d
         result = x + y;1 C+ c/ Y: I* P3 b* }6 |0 ^/ D
         break;
      case '-': + M; R, i9 i6 Z/ ?+ u
         result = x - y;: K7 Y4 G7 n' M7 S3 l3 Z% v0 V
         break;
      case '*': % }2 Z  S9 P( h' X- R$ g
         result = x * y;
         break;
      case '/': 4 w$ o4 z2 M5 X
         if (y == 0)# z" W. P1 I1 A
         {
            printf("Divided by zero!\n");7 ?- u+ ]; V  E
            return 0;  X8 m2 f& a; P$ `
         }8 S: v; e9 L, ]6 s. Z/ Q
         else
         {# J3 H) A7 y6 c4 k/ n% w; v
               result = x / y;
               break;
         }
   default: 2 x9 R& e* @0 ]
         printf("Bad Input.\n"); $ H/ `% R  z, g% j
         return 0;8 u) T+ O  f! h8 K- s' j
}$ P* O: N* ]9 V" [9 L, E
return result;
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;! i/ B7 S4 f" T* O
char buf[16];
int i=0;
# P7 E  p7 w. u& O
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
) {" [# p+ h  k! l( N8 P
printf("Enter your expression:");
      6 F+ _" d  t; H: f$ X; o5 a& x
opr_in.ch='#';# e  ?/ b5 }  k+ J$ u; G
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);" M0 K) z- H8 \  _  `. W
c=getchar();" l  ?  E( Q6 j3 H8 g: V
while(c!='='||opr_top.ch!='#')8 e0 |# K! U1 h! q( t' Z
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/$ A& k: `1 r+ J8 W# h9 T
      {
         buf=c;
; h2 `+ g% d2 ]" ?, B& W# G9 E' S! @          i++;
; h4 g6 }; H: i" ?- d          c=getchar();
& t* j0 B- h+ S" O       }
  U4 C4 h0 P- ?( v       else /*是运算符*/$ M; U0 h$ V6 F* b
      {0 @2 G5 k* o( F, ]7 ]
         buf='\0';
* O& }2 q" o; n+ \) F          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
; G3 K! Y+ q/ a, l          {: F/ N& i: ^# a, R) r
               opn_in.data=(float)atof(buf);. t) ?" c/ {5 T) j6 a
               Push(opnd,opn_in);6 i9 f1 `# g  L7 L2 q* x
               printf("opnd入栈:[%f]\n",opn_in.data);# x9 \% x# a' W( g1 w: y
               i=0;
- C" A( O. Q: l- k2 r! Y                memset(buf,0,sizeof(buf));
' w1 m% S1 x) B/ x, o3 W2 R          }; c3 X: y! D3 h
         opr_in.ch=c;
2 W! L; o& ^# t% R3 a& @) _          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
+ `! }" n( s; U& U/ ^4 b3 `          {) m0 a( m- k2 T' @3 [
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
/ R" M4 p7 f: f                   Push(optr,opr_in);6 w; b7 {6 Q0 B, T. v7 ]# z
                  printf("optr入栈:[%c]\n",opr_in.ch);
2 c5 p3 l8 u( T                   c=getchar();3 O0 q; F' }' S5 E' \7 T. n
                  break;
( Y" c3 {) h2 E" {' H# _             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/+ R; n1 O* J6 l2 O+ h
                  Pop(optr,e);
  K& w5 l2 Q+ X) c: ^0 `! A9 d                   printf("optr出栈:去掉括号\n");3 {" A+ k8 c; z. E' S- S. e5 d
                  c=getchar();5 g, d) e+ B8 l0 S) E
                  break;, R3 l2 Q0 i5 r" l# X
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/: P* n! I1 D  n$ p* g
                  Pop(optr,opr_t);
4 j3 ]; S$ b- k# S% n2 L0 m( j                   printf("optr出栈:[%c]\n",opr_t.ch);0 b+ C$ Z4 g' H2 R4 @% r& G
                  if(Pop(opnd,b)<0)% W7 y8 _8 ~7 L7 f; V, j3 `
                  {
7 u( G0 T; Y8 S6 g& a: `  G* `                      printf("Bad Input!\n");: k# \2 q3 W+ ?4 x1 v& R' w
                     fflush(stdin);
7 ?) w9 k# p0 `6 w                      return -1;2 |1 y: J" p1 W1 F! |* T" C3 r
                  }
( P8 W0 s) j0 H  U% @) f                   printf("opnd出栈:[%f]\n",b.data);) k: ^* v5 x% ?/ }# Q7 k% ^8 t3 F
                  if(Pop(opnd,a)<0)0 y4 j" O6 e( i; V0 O; Y
                  {) y; [- e: G& b/ T9 G  i1 k
                     printf("Bad Input!\n");
1 K5 ~) c3 c. U. v6 G6 R                      fflush(stdin);% U4 n/ K! t% a/ u
                     return -1;
$ o2 k# [- X! V/ z                   }
! `& k0 q  u6 }( t+ o                   printf("opnd出栈:[%f]\n",a.data);
3 L" ]8 Q5 Q; G: @) g* O                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/1 x1 b9 L* B- s9 o  F; u+ K3 j3 ~
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
( l/ W% w7 h* u6 w/ C                   printf("结果入栈:[%f]\n",opn_tmp.data);6 J. c# ~" t. W8 a. l9 K$ l
                  break;
" ~7 k: ^' [" H5 G* j+ C          }
9 p. s/ F4 N5 J8 b8 w, o5 `1 ~; `       }* ]1 u- b( K1 O/ O
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
0 A' D5 s8 }0 W }0 u$ ~/ a8 S% t: m% M$ d1 r# I2 x
GetTop(opnd,opn_tmp);
7 @% X+ _: C; C2 c DestroyStack(optr);
4 _: H4 W1 h, {$ o DestroyStack(opnd);) o. u1 @+ ^- u( U4 p2 H
return opn_tmp.data;6 Y6 d% |9 X% G6 N& K+ S: O, z
}
* t- T' v4 X5 E0 E- B# D8 N
3 |3 V1 J* @- \% L3 i8 `char *killzero(char *res,float result)
0 Q" ?" {. O$ w4 ^{% ]1 O- ]5 f, H4 v* d
int i;, k5 _# g2 f% Z9 O3 h

) K) c5 I+ a5 ~: e3 P  k sprintf(res,"%f",result);
' `% `7 k. y- h i=(int)strlen(res)-1;$ w& n9 p0 ?$ L! D3 A3 S' Q9 \: }
while(i&&res=='0')
) M" r3 t( U/ i) b. T {
' g0 p4 r! X" u$ M7 X' X       res='\0';  A/ R8 J0 Y; D+ `1 o8 S; o
      i--;
- h$ V, V- V" `7 k, h }
; I% Y% w" C7 i6 t' e7 h: v if(res=='.')
8 V8 j8 ?# r- l0 Y% c8 K       res='\0';; @% x1 D8 _: Y$ }$ ~4 t$ i4 K, z0 r! z
return res;, J+ M7 i8 i& M( ?
}7 L+ m! {( o5 h$ ?: G4 |7 p8 Q  t: W+ y* u

6 P3 \8 b& l8 q( T! q2 \int main()- W( G% a1 z  E4 f4 O+ x1 Z
{$ D0 u: @- f. K4 ?; s
char ch;
6 [/ {! l, f$ a5 l" I char res[64];1 L  b# f. D# K- K, P' x" A! U
float result;2 e" Y+ n. k# w) a* V
while(1)
0 @/ K" r0 ]  x1 ]; } {1 O2 [9 M2 Y3 |! m9 f" z+ I
      result=compute();5 R0 ]1 u5 @+ M! v
      printf("\nThe result is:%s\n",killzero(res,result));
1 T: [2 `: A; J3 g- @' L       printf("Do you want to continue(y/n)?:") ;" b: }* e6 L& s- W5 ^; k
      ch=getch();
: f! f' p# y3 Z4 L+ T0 E7 }5 k9 V       putchar(ch);
" V  o: U* H- K- P       if(ch=='n'||ch=='N')
6 Z- n# W% k7 M. L2 B1 I          break;! b( ^1 |. S  w
      else0 }+ L0 u( K/ [
         system("cls");
0 t0 Y+ J: l5 A) Q9 p }5 v+ b* {8 W% M. d9 a5 P8 A! o1 e2 \
return 0;
! b) s; H% |! Z% V% H$ D5 G}

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

返回列表

C语言表达式计算器

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

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