C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.1 U- ]7 a( O* \  ]
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=6 e- ]8 P3 C: r4 e
/**************表达式计算器************/2 U8 k3 N1 \) \+ g% e
#include <stdio.h>$ k4 c0 ]  `/ Y: K4 @
#include <stdlib.h>1 N, e' K$ U' ?- Y6 O  e; p5 `
#include <string.h>7 M6 M! r2 A4 i3 K, X, s# M; ?
#include <conio.h># Z6 x  n  p  e/ y( E
#include <malloc.h>1 h6 y/ D, [* d+ M8 r$ r8 r. }) {& }

#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/8 [! y9 q# k! K3 `" m
char ch; /*存放运算符*/. E/ A+ O( T8 I7 C. C' j
};: d" y! r1 |6 W% E! G

struct Stack{* i( E2 P) h8 Z6 h% _1 ]
SNode *top;6 ]# @) @; m- Y9 Y3 h
SNode *base;
int size;- x5 ^. |( E2 g3 i
};
( v9 r- l/ N: V" J/ @& N  _
/*栈操作函数*/- m1 @7 @( g( u! ]
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/5 s& C# O- `  E" z1 x) p
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/2 P2 v) M% o' w2 ]4 v2 {
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/2 n. S7 n5 ^: S+ x4 ?
# P8 V1 S0 i5 c
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/. h6 c( q- l6 p# @, g7 x
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ & [* |: C. k, L* @7 ?: ]
7 a8 f; n8 m8 x" M) I
int InitStack(Stack &S)
{% T. Y5 g& s5 j2 a! T$ n" I- P
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));- v! m8 {# y( L% ^; G/ y
if(S.base==NULL)# g' V. R9 ]5 b: N- A
{( P+ e6 l+ `2 v1 R7 @  f
      printf("动态分配内存失败!");! a8 |; ]( G( H
      return -1;- s5 m" y: F% [  P( j* I
}
S.top=S.base;
S.size=STACK_SIZE;# ]0 V! C1 [* J# [) ?4 P2 Q
return 0;( g- |+ ?: ]( d
}

int DestroyStack(Stack &S)5 f2 W6 j+ @8 O
{
free(S.base);
return 0;
}$ f( w9 i! z. ~! `2 L6 i& _

int ClearStack(Stack &S)
{2 @% W! d/ f+ n2 u7 a7 H+ g8 W
S.top=S.base;
return 0;
}3 l  A. t! |4 u9 F7 q

int GetTop(Stack S,SNode &e)  n2 O  T' f: ^8 z4 G. ^& o6 g) {3 _
{+ g" N0 C4 G+ |1 f
if(S.top==S.base)4 V  F& |4 Q4 [+ L% z4 j7 ~
{
      printf("栈以为空!");
      return -1;
}% Q: P6 ?( G. ?: ]  `
e=*(S.top-1);
return 0;
}
; W, P7 |8 k! W& v
int Push(Stack &S,SNode e)
{9 v# ]: `/ }3 ~( [4 i; T7 F
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));( m/ S6 n6 S) R  h, I' X* Y
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }# K* `( b* r$ U1 d1 w3 w1 |
      S.top=S.base+S.size;: [+ `" P& ?3 J6 n, ?- _6 D# D2 a0 r
      S.size+=APPEND_SIZE;2 f2 _, q5 V% t
}
*S.top=e;
S.top++;
return 0;
}
8 V% B' ]' J+ U2 v' N
int Pop(Stack &S,SNode &e)6 f( W* b$ q) r5 e' E  K
{
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;
}
e=*(S.top-1);
S.top--;' h! l1 @! y* n% r# y' d1 W9 g
return 0;
}' K" H9 i2 T1 F5 h* u' b

char get_precede(char s,char c)
{+ T; V- U  k) K( w$ f
switch(s)
{
      case '+':                - C- b! k0 l5 c8 _1 ?! S
      case '-':# c' o+ z" ^; t- ~: w" p8 \
         if(c=='+'||c=='-')1 Z+ W* s0 I7 D* _3 m% e, D# ]
               return '>';; z% z2 U6 l! M: u# b; D
         else if(c=='*'||c=='/')
               return '<';) {) S5 Z$ q& v' U1 U3 L
         else if(c=='(')
               return '<';- [1 f& J7 |' B; q- d; P+ _
         else if(c==')')
               return '>';: P2 w( ^& |& D6 O. l! @: w- I
         else
               return '>';
      case '*':
      case '/':* w) r, H3 w3 S/ Z; F
         if(c=='+'||c=='-')
               return '>';2 A0 B. r6 L, P) E  [' ^7 p
         else if(c=='*'||c=='/')
               return '>';7 x$ ?- b' q' K- X' w, o9 g1 |
         else if(c=='(')
               return '<';
         else if(c==')')+ v( J# F* O5 R0 l# n
               return '>';/ r* ?1 I' t$ Y2 _$ Z8 f3 g) ~
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';( j9 J% a6 Y5 W! }  b+ |/ R: q4 s5 L. u
         else if(c=='*'||c=='/')5 p  ~0 b* E! ]
               return '<';
         else if(c=='(')9 \% u/ `4 x$ f; s' c( `( J2 a
               return '<';
         else if(c==')')
               return '=';; O, ~& \6 [, G8 R: ^! h, a7 k: m2 ~% n
         else" a$ b% m: ~$ V# f! \% I& o
               return 'E';
      case ')':6 K" y- _7 e! m! {' v
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';7 }5 p6 Y$ ~/ Y  V$ I7 l4 M' ?& {3 `
         else if(c=='(')
               return 'E';/ {; ?4 I+ n/ E) q7 H4 Z
         else if(c==')')! i8 P; p. I0 `' g3 {
               return '>';
         else
               return '>';
      case '#':4 ]3 z! E7 X6 m
         if(c=='+'||c=='-')0 q) M" R  b  [' D, |/ m
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')' b* w0 E( s6 _- g5 L( z
               return 'E';
         else) `6 q8 Y5 U& [
               return '=';
      default:
         break;, k( k; V) a0 O5 N
}
return 0;   E8 P9 N' C% ]' d
}) ?* G  h  A" A3 G; m! v3 ]! t
, \' G7 s9 L7 n: o1 N" w
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else , X8 ^& o8 K# J  I
      return 1;
}: B5 R9 Z% p3 b, u
% w: z7 b+ L5 q9 ~
float operate(float x, char opr, float y)
{
float result;
switch (opr)
{% w4 g9 u0 R; \" Q- m
      case '+': * z- u3 ^; x  [) C2 H. _1 `
         result = x + y;
         break;
      case '-': % o2 _, F. h$ k4 P
         result = x - y;. b( y4 M  ]# H6 @  T8 }3 Q
         break;7 u2 Q6 ~; c1 }3 Y+ W9 L
      case '*':
         result = x * y;
         break;5 P+ P1 u6 P3 w- p; f( M
      case '/':
         if (y == 0), g, ]8 M# Y# h
         {
            printf("Divided by zero!\n");
            return 0;* Y7 q' Y( `" e: B7 e
         }
         else/ D3 w2 p1 ^8 g5 e# b& }
         {
               result = x / y;) ], ~* s$ w9 r+ \# i- w2 A$ |2 b
               break;5 ?; M- j# ?  B8 v/ w' Q0 `
         }. j/ {+ B1 u. O3 B2 h) z
   default: ) ~, J  \/ e& O! L- [9 z  c2 }
         printf("Bad Input.\n"); 3 O6 B0 Y9 V/ f3 W) v
         return 0;
}
return result;
}
4 |3 p4 k6 b" h" k2 P
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{0 a9 H* m0 A: ]
Stack optr,opnd;/ t5 w" Q& i* C! g1 f9 p1 K
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;# D" r+ t  t/ J  c5 a
char buf[16];, }3 b1 Y8 E6 M
int i=0;: j8 Y, d* |1 ~$ X" d# U

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/9 o: e; M9 T' g
memset(buf,0,sizeof(buf));" I; }- U3 Z2 ?+ X( \% G: `

printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/5 S9 W* I: E9 q% ?; [; v
GetTop(optr,opr_top);5 W) m& D8 ^, {: s$ h/ o
c=getchar();
while(c!='='||opr_top.ch!='#')! e4 A# i. q) o
{; f: W2 W$ V9 E
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;" U  K  o( X; y( q3 x6 F
         i++;' t$ f  P, G  t5 g' @
         c=getchar();; X: h2 E  M( H' E/ @
      }
; p! `8 r! |) d1 {6 e  ?4 t/ V       else /*是运算符*/3 o1 b/ a$ U! C+ E; Z' E) i, {1 a  m
      {
6 e9 V' H1 c; {0 q. y8 L0 Z2 v          buf='\0';0 K, I. O2 T1 C! T
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
7 b# M5 f5 y5 O9 j          {
1 A6 u2 a9 ]0 S7 H% {% x" L                opn_in.data=(float)atof(buf);
) c9 u9 Z& K4 w3 H* \2 y                Push(opnd,opn_in);
6 W" M+ p7 C. h& R9 q                printf("opnd入栈:[%f]\n",opn_in.data);2 A2 h; H8 V+ d; K" s+ D& P
               i=0;! ^3 b, I! g! B, X6 z% k& z
               memset(buf,0,sizeof(buf));$ x; V# t$ U( c# V, @" B& A
         }# v2 @4 u. _& s# v
         opr_in.ch=c;- h. U8 Q, K$ i. d9 o( p- {" j
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/6 t- v& G$ f6 X: d
         {
. l" d3 d& X, p5 I/ ?( R7 X4 W             case '<': /*优先级小于栈顶结点,则运算符入栈*/
, B* d6 _, |* o+ g/ Q% ^/ @! w                   Push(optr,opr_in);0 T/ b, |* I, ]
                  printf("optr入栈:[%c]\n",opr_in.ch);
2 p5 E2 u! F  g/ l) x6 H                   c=getchar();8 v3 R& E& |+ a4 u- k
                  break;
$ y0 a% J3 J# i% i# _$ z             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/2 C( S  g1 G& S( d: i3 Z; h
                  Pop(optr,e);. q( b0 m) |- L+ \0 [* y: l" H. O) ^
                  printf("optr出栈:去掉括号\n");
8 t$ A+ |  N  l9 O8 x  ]6 |                   c=getchar();
/ y$ B, m# B% ~0 p- N                   break;
. l8 ]: [# h$ m0 P2 F+ |4 `             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
7 c$ n4 w! V! f                   Pop(optr,opr_t);. Z3 m* P# ]: V' n$ A9 D! P
                  printf("optr出栈:[%c]\n",opr_t.ch);  t$ z# Q& t; c3 g1 v5 j& H/ X
                  if(Pop(opnd,b)<0); w1 }8 K; S& u4 e
                  {
7 X) U* `+ L. g, y# g                      printf("Bad Input!\n");" {3 b+ m" A: [2 n  t: D
                     fflush(stdin);. m- F0 W2 m9 N! p
                     return -1;' _+ U3 B, a. ^, K. F
                  }3 e1 _* T  D' P
                  printf("opnd出栈:[%f]\n",b.data);
4 `( h1 Y, w' C' m! _" ~7 L                   if(Pop(opnd,a)<0)$ Y- S" A( C5 M
                  {
" D, G6 z! c0 Q                      printf("Bad Input!\n");
1 W0 h9 I1 U8 _! E3 A                      fflush(stdin);/ q1 p2 ~& ]# p* I, P* L
                     return -1;0 p2 q6 S: l  P' l9 K" F
                  }/ z) l' T7 O3 o( x& u. R* f
                  printf("opnd出栈:[%f]\n",a.data);9 O. x$ s, L9 i& k* o$ b& t$ T) T
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
$ R. w$ G3 d8 ?$ I( O# ]7 S                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/3 e& b% P% Z9 o, N2 \. A. F, I2 K. t! R
                  printf("结果入栈:[%f]\n",opn_tmp.data);3 G1 x! T! y* l6 |: K
                  break;  g. s% C( ^8 r
         }8 l3 {: X; A" A7 c/ Y
      }3 b' ]" e1 R1 v8 J# u
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
) D+ f6 Y8 g$ v! T; m" q2 h }) A& e* c; S+ {; h' z5 B7 V1 O
GetTop(opnd,opn_tmp);
' g. y* E- b6 g( }+ J, w' o DestroyStack(optr);- o  [, X. Q$ n$ p; G/ B8 H
DestroyStack(opnd);
( o3 R: T/ M3 `8 i3 {# h return opn_tmp.data;
8 ~3 ~% c5 D, y  N. h0 v' V}
; O/ ]# e6 Y. d8 l1 f9 X9 {* H5 k  M# d  c! F' a, d6 O
char *killzero(char *res,float result)
* L7 }" e" O- f. Y$ R5 W/ u. O{, y/ F* g/ p% h( A9 _
int i;
0 D* E1 [9 n: w; v
1 _  |+ J5 }% \) B sprintf(res,"%f",result);
7 U" y; c. f; y( d2 t7 N: K i=(int)strlen(res)-1;
( v7 c- ~6 y6 y  m5 u while(i&&res=='0')
: S% e+ d5 {6 D" D {
* I+ N9 X) ^- }! A4 w2 n       res='\0';
& k) C9 n# P& u! F* a       i--;% }7 G9 V1 w; O# H1 q9 X8 A
}/ R! B+ V1 c, X' z( x$ P
if(res=='.')7 o8 G1 i' _8 u' N" [8 r0 `3 a+ ]4 P1 w
      res='\0';
# f4 C4 y1 V$ ]9 B; @2 h: N- G, Z* k0 O return res;
, n. @- Y  F/ R& e2 m) P}6 E. A0 ?3 c% R( Y
" M4 `+ [; Z, Q' P' k9 d9 k
int main()9 U9 r$ H( G: G7 j
{
, S% W+ i2 _7 @* Y2 O. Y) { char ch;
4 x1 p2 l+ U6 N" k% ?. |& v4 J char res[64];2 J( p: F" k* G
float result;
$ r8 g9 k3 }: q while(1)+ Q% u0 d& h" V; o( {: I2 o' c: j
{
$ }+ X, ^% s2 _6 Z; Y/ Y/ W       result=compute();2 g* d: G* M/ A" A  S1 O: t2 ^1 a
      printf("\nThe result is:%s\n",killzero(res,result));
% X' [  e3 X/ |3 v  ^5 b. y       printf("Do you want to continue(y/n)?:") ;
1 n! E: }" U" x6 e* T- Y       ch=getch();* S) a% }/ C: V3 ~# W' m
      putchar(ch);
8 R* w+ h# n* o( V3 i  d       if(ch=='n'||ch=='N')
' |9 c3 B( i, X# G  `: Z3 A8 [0 |          break;+ p/ W9 @! y; J! T9 Y7 X+ z) M
      else/ B5 \( U/ K- }) \& J
         system("cls");* M/ O+ d+ Z4 X: x1 \8 O
}
6 l9 p$ _, }: j) B7 T) D$ d return 0;! }: O0 ~: u. h, h
}
; v8 X1 G' g5 k$ i7 E$ ^5 W% X3 }
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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