C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/3 c' o- z, j. ]. p& ~
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100- j6 t' |% q; x7 C: V
#define APPEND_SIZE 10
0 ^0 h5 L) y' b; p+ ]% f6 ^) l$ }
struct SNode{
float data; /*存放操作数或者计算结果*/  \6 Y0 }- m% d. I8 I8 V; f6 z
char ch; /*存放运算符*/4 B/ F; O( C3 {& a, ]- `" g; c
};/ X  G7 ?9 ]* z" s$ ^  c# Y

struct Stack{
SNode *top;
SNode *base;
int size;
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/) Y8 t& ?  N+ w
int DestroyStack(Stack &S); /*销毁栈*/; `3 ]/ y+ ~; F9 E  x$ B# M
int ClearStack(Stack &S); /*清空栈*/% \; v4 e* Y( |
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/( f& r- W) ?( W5 s
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/
: S% H; g# i* t' ]( H3 k
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/9 \5 L/ R8 q% X, H0 Z
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ : j5 W1 O/ |8 p# b; T+ w# s! F6 E) G3 r

int InitStack(Stack &S)' t' G0 T. F' d5 s+ V* m' P
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");0 S; R) J8 T, P$ j' x5 Q( E7 C1 {  U
      return -1;
}
S.top=S.base;
S.size=STACK_SIZE;4 a& [8 E7 _, c7 D* i+ m
return 0;
}

int DestroyStack(Stack &S)
{
free(S.base);3 t4 q; Z' n9 `& k( ?
return 0;
}
# U& P4 p; J% W) ?( X
int ClearStack(Stack &S)+ S- F  h' T4 @6 }4 g
{+ i* ]! i2 u# C2 P" u& j
S.top=S.base;
return 0;( Z* O' x& `# s+ i; E. e6 h
}

int GetTop(Stack S,SNode &e)
{+ |& f7 u0 W6 C6 B: r3 W
if(S.top==S.base)4 e( {4 o8 X. a2 w: t
{
      printf("栈以为空!");- k$ Q( M- O2 A# D6 y
      return -1;
}
e=*(S.top-1);3 }' q% {5 P# t5 f0 V
return 0;- x" a! s0 \# Z) I# u
}' H4 Z! q2 z# u3 n

int Push(Stack &S,SNode e), D0 {, m8 z" i) N& F
{3 z+ c; H5 L' ^' {: O
if(S.top-S.base>=S.size), j4 @2 E; j/ b" I- v
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));. s* [: U0 h. S- m8 ?: ^
      if(S.base==NULL)
      {5 {+ t; u; R" _: r# Q% h
         printf("动态分配内存失败!");' N$ d& }5 y% f) Z1 \
         return -1;7 j3 K, c% n6 f) K2 _
      }
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;: x6 t3 f& R) D5 ?7 v& F
}4 c2 c3 \. Z5 H/ C3 b4 |
*S.top=e;3 z5 C7 `9 m) @, H, e" D! s( \/ |
S.top++;3 L5 Q- n1 P5 g6 b" M
return 0;
}: v1 G9 u6 K* a$ }6 {5 h- P* k
8 u  S5 S! B, y. @% L. N
int Pop(Stack &S,SNode &e)1 L9 d6 \) ]5 I5 U2 e
{& X2 _9 G7 G2 t* n0 i9 r( o
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;+ R  }" E7 K6 v5 \* K* Z# i
}
e=*(S.top-1);8 [: j7 N2 w) v+ I$ j0 \2 ?2 {% j
S.top--;
return 0;, [6 O( L, _$ @2 M
}+ ?8 n0 T3 n5 W0 @+ R$ M  A+ U2 T
0 |+ i( e) t4 c- Y- R% i3 ^# ?
char get_precede(char s,char c)9 F' ~# k* U  u  \
{8 U* ^2 {* x0 s  j
switch(s): ?; s: {! {2 W* L  y; D
{
      case '+':
      case '-':9 b/ x6 J( Y+ q+ M% E$ d+ ]4 Z
         if(c=='+'||c=='-')
               return '>';4 i/ c# v6 _0 A2 N
         else if(c=='*'||c=='/'); q0 a) _2 c/ O  V& k* \
               return '<';9 a; w  e" [/ s' e" S) ]
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';
      case '*':
      case '/':" b* t9 M4 \: j* R% d( g# Q4 U( v8 L
         if(c=='+'||c=='-')6 b; }* A. Z  N( v+ u
               return '>';
         else if(c=='*'||c=='/')2 x0 D2 @, v1 e0 J& d0 y0 U8 \
               return '>';
         else if(c=='(')
               return '<';# X9 s% V/ A/ M5 Y0 o- t+ K
         else if(c==')')
               return '>';
         else6 q) Z1 {8 U' Y3 ~: p) E
               return '>';+ U" s) E0 Y7 |# Y! l; b' E5 }
      case '(':
         if(c=='+'||c=='-')
               return '<';' \4 u" \7 V. p2 m
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')# c5 C, W# j/ a7 b8 g
               return '<';
         else if(c==')')+ O* M7 t) ^  ~3 ~/ @+ `6 i
               return '=';8 l4 H/ I( g7 {% `: Y% v" u
         else9 L" @# t2 P+ R
               return 'E';
      case ')':/ K& o1 p; G4 I0 o2 S- d5 H% B* G. M
         if(c=='+'||c=='-')
               return '>';- y+ t7 F0 ^. f8 t; t, D
         else if(c=='*'||c=='/')9 B. \1 r3 V: `/ `& ~, O0 T6 a
               return '>';
         else if(c=='(')
               return 'E';. }9 H) m+ x$ T7 C
         else if(c==')')
               return '>';
         else+ H8 W9 a. x- K6 J* h5 T
               return '>';
      case '#':# T. D! C% s$ ?1 v# B3 I" J( i1 m
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/'); C9 L- L+ h  O, ~! f6 j
               return '<';; _! f+ n7 S: j: p6 d5 E2 c; H3 r
         else if(c=='(')- c9 m$ ]- B: e, x& c; H
               return '<';
         else if(c==')')
               return 'E';2 {+ q1 u; u6 o: D9 H* ?
         else
               return '=';  P, U1 t: U( D6 b* y  e! n
      default:
         break;
}) g0 |1 f& v: ?
return 0; % k/ z2 t$ t( x! |8 ?* r1 v1 g  g$ D
}& h. s: Z. ~- h8 t2 B
" `+ \5 V3 [; e9 R- z
int isOpr(char c)
{- {" \0 V2 d, ~- O6 A
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;' t/ Z, i* Z; Q3 J" d3 t
else
      return 1;
}( \' L1 Z5 y2 O; i; |

float operate(float x, char opr, float y)
{
float result;
switch (opr)& A! y: d' m' j% ^7 f& V
{
      case '+': . A9 H5 @2 M/ M0 O: N( P% H4 o2 V
         result = x + y;
         break;/ k1 _8 T% U# F. S
      case '-': ( ]. M% R3 ?+ S6 G: H' w* j
         result = x - y;& L8 k0 M" m7 t7 n. G% @
         break;
      case '*':
         result = x * y;
         break;+ J0 i8 ?1 N7 G2 U6 w8 s
      case '/': 8 O3 }+ S4 y+ k* `# x+ _3 N' f" U
         if (y == 0)$ k! t( K5 z; V! n) s0 D7 B
         {, q% m* D+ I  z! D
            printf("Divided by zero!\n");, f+ k8 Q# E0 R( g: x: u6 }* m
            return 0;' b; l; f; J4 x9 p: |, N
         }5 z5 {# U5 Q2 n! Q& _/ a
         else
         {
               result = x / y;4 m) U# u. ]& Q  T9 g
               break;
         }
   default: / r! y9 x* a. k, d5 H5 w
         printf("Bad Input.\n"); " h% i. t* `9 T5 P
         return 0;
}1 O0 C& U( |& o) E1 E9 H: d
return result;7 p) Y& \% B; T9 F1 S0 Z% X  U
} * k0 ^7 n' d. |
+ ^  B! ?# L; B
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/% ~$ v0 X3 z" y' i3 W' W. s
{: T# B8 _) X2 `: ^: P6 y. K
Stack optr,opnd;3 Y6 d9 u1 H4 t* K3 j$ \; p' M
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;$ b- r( F& ~# T
char c;
char buf[16];: ?2 A/ V, I9 u  U
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));, l, v! M2 l2 T4 X. \

printf("Enter your expression:");

opr_in.ch='#';$ a4 ]7 L5 M0 R& s% H0 w) R
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{% a( K: z$ ?( L
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;) p) A& q( \* X/ V
         i++;
, `+ ^2 K3 t) O5 f3 w% N  t2 ?6 r3 e          c=getchar();
1 n4 R  D$ B, W. _/ e( r       }
% y' o' A' q: c* y       else /*是运算符*/
' V: Q6 F  S" @/ G3 I& P! G5 O8 V       {
) c2 r# K7 j3 c0 a# I& X          buf='\0';
& H8 N+ ?7 i& O          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
! {. ~( \) X* a: W8 L/ M          {
8 B/ x% M0 H5 n, t- k5 D: e( Y                opn_in.data=(float)atof(buf);
$ q0 u( U" `. N0 w                Push(opnd,opn_in);
' G, T* X" g; M0 o                printf("opnd入栈:[%f]\n",opn_in.data);$ W% ~7 I4 X- `+ l3 x  b
               i=0;
2 l/ d3 ~3 l' f* F$ y* I, j/ ~                memset(buf,0,sizeof(buf));9 n* i7 ?/ b6 [2 E4 `
         }
' \8 n- K5 A5 T3 r3 i' k          opr_in.ch=c;9 C- e+ e8 J- t) _* U
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
( F) M% |1 z$ v6 {/ }7 k1 ^          {$ R0 }' D: z9 {0 W" X( \
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
8 i3 d* x, D1 K                   Push(optr,opr_in);
1 h0 ?: v" G  u  l. M                   printf("optr入栈:[%c]\n",opr_in.ch);/ w  A2 ~2 r) V. n$ V
                  c=getchar();, M' c  E9 N' a# @. |! W
                  break;
/ r8 `/ a2 J* t6 V. H4 z$ I             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
* K. q' C% R% b% F/ ?  @8 D  c/ _                   Pop(optr,e);! e4 j# l9 d9 j. q: d6 Q8 ?
                  printf("optr出栈:去掉括号\n");* i( C! K9 q& N& c4 |7 w) A: g
                  c=getchar();& i" T7 W, x0 J# l# F. g. S
                  break;$ E/ e9 P( {  Y6 y) w3 a
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
1 L  I% E8 I6 |$ [                   Pop(optr,opr_t);
2 s) W, \( f, t, b& p                   printf("optr出栈:[%c]\n",opr_t.ch);
; J; {: g/ E" ^* G                   if(Pop(opnd,b)<0)
# N9 ]) M. K1 {) R; l                   {
1 }6 O" f3 y7 E- n: k/ K0 z- [                      printf("Bad Input!\n");
4 R' O: O2 q# ~6 R                      fflush(stdin);
4 B0 U' ^) ?9 N                      return -1;  h3 d: Y5 a0 j; Y
                  }
( Y9 F$ h; P3 Q" v- z5 Y+ B                   printf("opnd出栈:[%f]\n",b.data);
) N, ]  I$ S6 {                   if(Pop(opnd,a)<0)
5 H! i0 `6 H6 v                   {/ D1 g- I, [" }2 K9 J
                     printf("Bad Input!\n");
1 `" {3 f) X3 _                      fflush(stdin);4 p- ^9 Y$ n) M# i% E, Q% I
                     return -1;
7 W2 k, l! K  L$ h                   }
: I" a# |: N/ q) v3 [                   printf("opnd出栈:[%f]\n",a.data);
! B4 s6 S* t/ P6 V* v3 @3 V                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/& w+ [& t* P* L  ^, s
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
; k; T/ c8 W0 e" F! L& B                   printf("结果入栈:[%f]\n",opn_tmp.data);
8 P2 t# |; o3 m8 m6 G$ u' i                   break;
9 \9 a4 a' @. z; ]% E( ^          }6 a! d# L2 v; \9 B- ]1 K4 p& B4 ?0 q
      }
7 D8 e  a: e$ F6 k# b9 I       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
# j5 x4 p# s* z' K' Z; ^2 C }
( O* R* F" p( d- n! r7 h GetTop(opnd,opn_tmp);
; D$ m( \/ ]7 ?$ ^* y4 W$ z DestroyStack(optr);
# a% W' x/ U% F4 K  X3 i DestroyStack(opnd);$ r: D7 O1 L$ D& c0 ^
return opn_tmp.data;
- D5 M- t) U2 i! M9 d& C}5 O* J0 ^( T; F
; M% M/ S5 v+ H& T$ W
char *killzero(char *res,float result)
7 u& h2 m( \/ z3 O& ^5 M{
+ f* \% r9 t9 `( E int i;( h& a$ k3 V# j; d2 o" d! T

) J2 u+ }* L- A sprintf(res,"%f",result);6 A( z7 P# ~/ K" r/ x- A
i=(int)strlen(res)-1;
; s) j' b" B- r9 h; o0 a  F while(i&&res=='0')
$ K" [1 c7 h5 h$ S' l4 W/ q; C$ b {
$ k: r) I; e: b  A# A' l       res='\0';. p9 {; p# y0 M, A7 U: {
      i--;
: M' t1 x; P* W0 `, S. F }" o0 W' A5 B% ]* S; K
if(res=='.')0 @7 S8 u) e0 Q3 V% Q
      res='\0';) v/ X2 z% {8 \% p! u4 v; @
return res;
( h+ H) ~5 ?' o: ]}
8 O# t3 ^4 L" N  o+ s
7 d7 S5 W2 r& t1 ?int main()) t5 G, S4 g& N! x& n. E  C$ B
{' `! N% V( D% d4 {
char ch;6 v6 G% O3 n" h* U' F& v
char res[64];
* \3 A1 C4 j/ ^/ w8 z3 ] float result;
& m5 ]( L+ A! _' { while(1)4 z6 O# V! _: I8 U) c
{
' ?' Q. p$ y; k0 D' F1 O       result=compute();4 ^# l$ k4 ], N/ |, |, f
      printf("\nThe result is:%s\n",killzero(res,result));1 j# M7 A+ ?) r" Q9 L9 R7 D
      printf("Do you want to continue(y/n)?:") ;- `' n+ _7 [/ h3 g" c
      ch=getch();
; Q5 H- z# `4 o  Z% N) z" T       putchar(ch);
2 ?) O0 G5 D" F# J% l, B  Y       if(ch=='n'||ch=='N'); `5 U  P7 O8 Q6 N" n/ t
         break;6 a4 |6 r4 t/ _. M) [. i' {
      else
& U2 `; ]- o% n5 f          system("cls");* n9 A- @- q' `$ [4 M/ G) D! ]
}
! w, [) g3 O% d( n return 0;1 y( a9 D: U! p" z8 L2 T6 a! }
}
" Y8 I% @& W) f/ r& I
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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