C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.( S2 H' D' C, v$ o
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=1 [4 {) _, K6 F5 G6 p
/**************表达式计算器************/
#include <stdio.h>/ f) Z" e' R3 w4 \! g4 ], z' C
#include <stdlib.h>6 Q+ H1 K6 x: ~0 q
#include <string.h>. I0 Y8 J7 r( V3 S# o+ D
#include <conio.h>
#include <malloc.h>/ R5 y$ G+ T4 d0 E* F

#define STACK_SIZE 100
#define APPEND_SIZE 10$ G8 B0 b8 R% E8 z* [) A
8 y9 \0 r) Z/ `4 w( H9 H4 m
struct SNode{
float data; /*存放操作数或者计算结果*/2 Z- t7 F& k: p- W7 X2 l
char ch; /*存放运算符*/  r9 \) w# L: t% t, v
};. R0 f, ]' P$ b' m! q& A
1 r2 W& }9 K8 W0 J1 _* k5 A
struct Stack{" U( U# ?: `  S; {1 ]
SNode *top;! U0 T8 ]0 a& R7 `5 P6 g( b
SNode *base;+ j' A' W/ z  @6 ?. H
int size;
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/% a0 U2 O7 X* W
int ClearStack(Stack &S); /*清空栈*/  n$ r7 Q+ P1 w: {* @
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/. d$ m8 U/ g3 d+ |. G$ ]* ?* b
int Push(Stack &S,SNode e); /*将结点e压入栈*/; `1 o0 T, t, C+ D7 N$ W
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
. k1 r. W; L1 d" A
/*表达式计算器相关函数*/
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(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
4 @: j5 m& z* N+ Y( d. A6 s' {
int InitStack(Stack &S)6 o1 o8 s( _6 F$ c4 g: I
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));/ y- d2 J, a- G: N
if(S.base==NULL)
{  o4 t6 x5 X$ Q
      printf("动态分配内存失败!");1 ?) Q1 H$ |; s& O. ?
      return -1;
}4 ?9 N1 \2 U1 u/ W# K
S.top=S.base;
S.size=STACK_SIZE;
return 0;+ m; r$ Y- B1 k! x  v
}/ i1 ]9 Q. d) O6 e' M" W8 r: X9 h
# A: S; p! S( |8 K( s1 l
int DestroyStack(Stack &S)6 d9 W9 N. c, n4 k
{0 T- ?" k* e( Z; @
free(S.base);
return 0;& a4 R$ }: M  c$ D/ y/ x$ }
}
* _" w1 }) u6 {' k- E
int ClearStack(Stack &S)" f7 ~9 v) M- C! t2 Q
{. ~/ e5 ^! z8 \. T: D
S.top=S.base;, t0 c' S: \+ c- Z1 n
return 0;
}
. S. x  U/ K4 E5 n
int GetTop(Stack S,SNode &e); w: ^. q% C: I* i0 }/ {3 ~
{0 v7 G( I# U6 r: s9 X0 g8 E+ t( A
if(S.top==S.base)# K. ^$ V9 r% r+ G% B$ j. j. C# x
{
      printf("栈以为空!");3 u) V" j# k7 {+ R8 a( b. c2 d0 W0 z
      return -1;
}* C& X$ N3 K* ?  g# @
e=*(S.top-1);
return 0;
}6 |7 \; X0 |; j* ]8 Z5 u: U3 l8 f
: j: w) [' @" P5 F+ e) k! }
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)% T5 f: I- b/ S; e) r
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));* b4 [& K: ?+ s4 Z! B3 Y& [1 Q
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }% i, f# C% S. B, U. B0 W
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;* {+ y5 g" q/ x' j6 h
}
*S.top=e;
S.top++;
return 0;
}6 ?# @$ z7 |+ N( ~: T

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)
{# ^, U$ |0 |- ]
      printf("栈为空!");
      return -1;" u$ F% I1 b0 _# v6 u/ Y
}! ]% G$ A& ?4 a7 X8 Q
e=*(S.top-1);) u3 B3 b2 ?1 S6 V7 l8 ?) [4 [: h
S.top--;
return 0;
}3 ]8 h% p$ Q2 v; u5 \
% }# b# L, v" Q; N& P2 }
char get_precede(char s,char c)
{: T/ P8 Q8 u3 ~2 ~3 @
switch(s), I, Q1 W, C: s0 w
{: h# p& h" \( C$ _1 ~$ f
      case '+':                ) ]7 H( X5 j1 A) {9 c* e
      case '-':( |+ y" G( z6 G6 `0 S* |
         if(c=='+'||c=='-')1 _# e  \7 G4 `: R3 n
               return '>';' o) W# b4 s8 X+ C' S
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';0 X$ O& T) C% e. Q$ T6 y" e
         else if(c==')'). [4 U6 P% ^' P
               return '>';0 ~; {! f: s5 d) e4 ?# s
         else
               return '>';
      case '*':
      case '/':9 V+ o+ K6 _: z  J/ W" m# _
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')9 K8 M+ K0 I) X/ F2 e( N" {8 H' j
               return '<';
         else if(c==')'); _4 o7 X1 ?% Q) I: i! P; E
               return '>';
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')9 ]* C6 `% b2 a: Y3 s$ A7 i
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '=';
         else9 U+ P! X. Y0 T2 J- {9 m
               return 'E';$ J, T8 ~& Y2 l, t
      case ')':( i* q+ p/ s& j0 ?! {
         if(c=='+'||c=='-')3 o2 F1 J7 v$ \2 e" J7 L- n% y+ r4 v
               return '>';
         else if(c=='*'||c=='/')( h/ O' y4 E$ H
               return '>';1 z& B4 R% ]6 ?- v
         else if(c=='(')
               return 'E';" }: o% _; @9 A& `& V) Z- ?4 L. T, _
         else if(c==')')' F; F, i( u! ]. i+ j# h
               return '>';
         else% O/ F3 h# x. [: z( M5 m2 D
               return '>';
      case '#':
         if(c=='+'||c=='-')+ `4 P9 J+ _5 E
               return '<';% n6 O1 C5 J, M7 c) ^- G& `
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')# C1 [# p& w) a* w! w
               return '<';4 m% m: p/ b: [7 [) M  p) z
         else if(c==')')
               return 'E';
         else: l, b5 a3 X$ b8 I" d5 k
               return '=';; L1 o3 j9 x/ a: O
      default:
         break;# N, a% }. V# q
}
return 0; / m) H8 h; ^! b# B
}! p1 s8 q  L) z, N. k
  C* [# I; A4 w' {$ k+ O6 W
int isOpr(char c)0 {5 p4 U1 x& W) u
{2 W- f) M4 Y4 i' ^
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')- V* C7 {& M% K! n6 q5 }4 A
      return 0;
else
      return 1;
}

float operate(float x, char opr, float y)
{
float result;- G6 G# b% Z4 s" \+ x# H
switch (opr)
{
      case '+':
         result = x + y;
         break;. W4 @+ v: M* j  r: g
      case '-': : Y0 z. o" h) K& V
         result = x - y;- w0 A+ o% G$ e' z' M& x
         break;5 d- H: v3 u2 k7 n; S* l
      case '*': " o- T+ @! |1 i( \* C' y, ^
         result = x * y;8 ~* ^) ^1 |- ~* R) X! C
         break;4 ~1 e+ p# W. b& ^2 u* u8 k: h
      case '/': . m* g& m" W* r/ D3 ^9 v
         if (y == 0)8 j, y+ f) U; ~7 W$ [5 l
         {
            printf("Divided by zero!\n");
            return 0;
         }9 E0 e1 r* w2 x, [3 ^- u' I
         else
         {6 r$ n! S3 j% S
               result = x / y;
               break;* |, [0 E' B8 ?  s1 i- S- Y
         }
   default:
         printf("Bad Input.\n"); " x) G2 _9 F" ^; _: O0 s! }1 g
         return 0;
}% f4 y4 m/ @8 f
return result;
} 1 t( j9 E6 l: B% R% R$ Q4 i. y

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{4 R2 y) P' B/ K1 `& T9 _) A
Stack optr,opnd;1 N8 d! L1 F+ H/ d: V
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/0 E" u0 s/ o: \4 N# u6 ]
InitStack(opnd); /*用于寄存操作数和计算结果*/" d0 e3 C1 D1 U: l. U$ v
memset(buf,0,sizeof(buf));
7 g) ?- R1 x* _' T9 b$ g" i
printf("Enter your expression:");

opr_in.ch='#';0 e. ~1 k" J; G+ r, C
Push(optr,opr_in); /*'#'入栈*/2 X7 j+ Q6 c1 p
GetTop(optr,opr_top);  P2 V1 g- h1 Z5 S  e
c=getchar();  |+ Z6 F* g& x' g, b
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/2 V1 \7 v" t+ R2 _( Q+ K/ D
      {! Z0 n4 Y* D6 h; o
         buf=c;: ^2 M" p  R$ z- Q
         i++;* @7 z' D' M: h5 j, [
         c=getchar();: d: @: `; `; I8 q" m
      }  O( x( y( ]. i$ r1 O
      else /*是运算符*/
- \. w3 M; h. Q5 p       {
: H3 j& h0 U- `4 |6 i          buf='\0';8 h& ~; Y5 m( V. W) k7 _# q
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
7 D2 m  @/ B5 N* v9 p* F  H$ U          {
1 g5 |  {: S  W0 N  M                opn_in.data=(float)atof(buf);
; s0 `) _$ B: w# V# K                Push(opnd,opn_in);
# O5 w7 J8 I% i8 ?, g! R" o, z$ G# `                printf("opnd入栈:[%f]\n",opn_in.data);
/ s) R4 t) S# q4 f5 j                i=0;- z: Y" P4 N, Q- o6 q6 C# N! T
               memset(buf,0,sizeof(buf));! S* D+ {4 \2 z: S% a+ L3 W2 w
         }
2 k5 w; Y0 |: }" G! D) s; x          opr_in.ch=c;
/ B4 Q- Y, n7 C# n+ v: F' v% ]          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
9 L+ D: S* _$ N          {
3 Q  N: m7 U# X) v3 [1 O0 |  I             case '<': /*优先级小于栈顶结点,则运算符入栈*/; \) ?+ H! |3 \! |
                  Push(optr,opr_in);
( A' P' J; P5 u7 A: ~                   printf("optr入栈:[%c]\n",opr_in.ch);
- P# a9 v. u7 z; U% M6 G                   c=getchar();0 `( @# T8 V% Q$ O
                  break;0 k+ ]6 S4 N; ^  v$ Y. {
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
) Q9 I7 a7 K. C1 l2 q9 u" \: u                   Pop(optr,e);6 e1 e+ Y; E: z0 ~9 A- _! e, x! W0 \
                  printf("optr出栈:去掉括号\n");
1 H; f) c) _& b+ Z1 U9 C# T                   c=getchar();1 f8 F6 Z5 q/ Z7 c( ]' ^. X
                  break;
& }% h; K; h2 Y. ^7 v8 U             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/( a9 q3 F8 ^$ i6 m+ S% N
                  Pop(optr,opr_t);
" K0 L6 N& h0 z5 [                   printf("optr出栈:[%c]\n",opr_t.ch);/ e) n5 I  {. ~9 r+ C# J
                  if(Pop(opnd,b)<0)3 _8 j& B: Y& Q$ i/ N6 ]
                  {' h- p+ s: X0 W: S* q
                     printf("Bad Input!\n");
# m& |3 u! F* X0 n                      fflush(stdin);3 x* H% P5 n& c$ @5 g( d7 n
                     return -1;' l# B5 e1 m4 A# q& t3 a( [: j4 c
                  }4 k0 ]1 u; b" K  D
                  printf("opnd出栈:[%f]\n",b.data);; S5 `% W/ M3 w$ C. N. Y
                  if(Pop(opnd,a)<0)! U* N1 ^7 C& R- Q' Y
                  {! G8 I0 Y5 Z* ?# o: o2 U; J+ g
                     printf("Bad Input!\n");2 K8 H+ y- G6 ?! x- O: e* L
                     fflush(stdin);+ h7 z4 m% b; l5 k5 {
                     return -1;% F2 d5 R& ~  @, T0 D
                  }
7 o) w5 l8 A& t0 J, S# `! a                   printf("opnd出栈:[%f]\n",a.data);0 Q4 a  V( S' e2 x# b0 E+ ~
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/" B: I* l- p1 G: h- L: f% |
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
: G: c( _7 ~" [9 S! f* i2 Y8 p                   printf("结果入栈:[%f]\n",opn_tmp.data);
7 g% K* i7 z* N& j* [                   break;
. B4 u) V; Z1 _2 R7 F          }7 V1 ^3 S* ^0 _% J5 F7 L  P8 ^
      }
! `  R8 l0 V; D4 G" k% {       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             1 @4 X" ?1 x4 V& K, }
}
: l+ O% @7 f7 ^  C0 o GetTop(opnd,opn_tmp);
8 \, A! r' P9 f" h! O DestroyStack(optr);
$ o* U( p0 y7 a# V  j: o4 l7 F  ~ DestroyStack(opnd);
8 O) g/ u; u! m6 Q% P return opn_tmp.data;
  H# o9 P+ C' S) y) E5 W}
: E( I) I& D. S1 ~! P$ ]' j* _$ ]8 E  P
char *killzero(char *res,float result)  l- J8 A. ?; p' z
{  p$ Q& ]4 r  H) {9 [
int i;
* _+ D& l% p- B, p/ n" {
  l( t6 G. w3 l, \' w1 [! [* [ sprintf(res,"%f",result);
# N8 L7 ?: v% Z' t, `, |8 F' M$ X i=(int)strlen(res)-1;
( p$ g9 _  t! x while(i&&res=='0')
9 F& r  D/ `- I; M2 G {2 I' _4 R7 f: y/ h
      res='\0';
' t# X8 ?. V, y3 i- l       i--;9 i$ c2 X0 _# U5 ?
}
  O7 E+ H6 I3 O- g0 f5 W if(res=='.')
- i: R* h0 J- d' |5 v/ [% S; [       res='\0';$ X, w3 h0 m  B+ i1 G& _; N8 ]
return res;
' v- J/ j+ [# H' O$ g7 O9 m6 X}4 B' L4 F2 j" k# ~4 S

1 P, y/ k4 m# F3 a' Aint main()
; P. n1 S6 b) h$ y: Q; c% K: h+ I{
2 N3 T. Z/ h4 A; [ char ch;9 Y3 b" x( V  K
char res[64];7 o0 K/ c9 d7 @& H0 _, O6 p
float result;
" I/ }; r4 x; R( ^3 z9 W while(1)
. F$ `9 M1 P$ N$ m& P {  B1 E. l' j( i% t! O6 |" V& N
      result=compute();
8 c3 Q* k( K9 j- [" A' e4 }4 n; Z       printf("\nThe result is:%s\n",killzero(res,result));
& G2 X3 a$ ~1 C& J( k: H* s: v8 c+ I       printf("Do you want to continue(y/n)?:") ;
9 h$ t: C- K4 r' c: I       ch=getch();
) K5 b7 Z* v) _       putchar(ch);1 @6 r6 G! O& C0 J; }& f
      if(ch=='n'||ch=='N')2 v: A0 y! }- W0 b
         break;
  e8 L( e1 f% n1 w       else
& [' _/ c. @0 U5 w! A) g          system("cls");7 ^2 q1 Z3 ^/ V2 e6 ]3 W
}
" T$ @: V1 }4 E, L: ^ return 0;: }* s7 U7 S; V$ F" s3 f$ s2 Y7 W- O
}
: X9 C) W* z* A* P  g
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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