C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.( a. E* C! }% B4 U
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/$ w! q7 x+ \% g1 a
#include <stdio.h>! f+ L, |8 o- S8 e
#include <stdlib.h>
#include <string.h># u1 v6 Q7 r: i3 ]6 D
#include <conio.h>5 {" |0 U& u: T5 @
#include <malloc.h>
% e3 c9 g/ g5 G) `% s) c
#define STACK_SIZE 100' ~9 {7 D, y1 o, h
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/# [& }4 `/ [0 ?  ]" Z
};$ n  ~/ V; i# U! L9 e( X3 n6 E  H
% o7 Y" ^- \# v* j2 s
struct Stack{
SNode *top;1 x( P0 G2 R- D; z; i$ a
SNode *base;7 N3 @( \8 Q$ h. a# u0 M
int size;
};& r* K" G3 ^. }1 O& b: V
, c1 J8 h+ d) j9 e
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*// ^7 S9 y  u! S. S. y, S- F' D. E
int DestroyStack(Stack &S); /*销毁栈*/& M( z# m0 O" j$ ?% t  |/ {$ n
int ClearStack(Stack &S); /*清空栈*/9 u9 X  c$ l9 ~3 K4 o
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/* y; k- [9 z8 U1 G) O8 Y# H
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/2 B0 n% t+ k4 h) g
. i2 i% s. j6 }* H* _$ Y
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/, m9 o3 N7 H6 t' G  \& b
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/% M" G4 F$ O1 ?: t6 x
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
1 D" {  `: _( ]7 m6 _5 X% i
int InitStack(Stack &S)5 L# N$ i- E, u
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)2 ]" [* m1 P' T9 T7 {
{
      printf("动态分配内存失败!");
      return -1;: Q. {% X* m/ E5 n9 m  J* d8 {
}
S.top=S.base;+ I5 n1 Z, l, f. Y
S.size=STACK_SIZE;6 S. F1 J, {3 D& `; p3 X
return 0;# K/ N% U9 g" v. S! W  ?
}: {2 b% D' N! D' v) B: T
: ~9 s6 \: i0 L0 W8 m( F* \
int DestroyStack(Stack &S)7 i0 p1 T+ E; [8 r1 z
{* Q( Q2 q* E6 S, p
free(S.base);9 q/ q3 F. x7 [
return 0;
}  i- H  y% Q. o4 Y
- r. Y6 U9 W4 b+ X7 ~- \
int ClearStack(Stack &S)
{
S.top=S.base;4 i* s- _) [" ?9 i+ {) m% O
return 0;6 g! V# g. H: K" I
}
# }: x7 x8 e0 Z" P- m2 {
int GetTop(Stack S,SNode &e)
{  S2 p- V( }/ w0 B4 Q6 j
if(S.top==S.base)
{
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);& |4 o/ z5 H; a9 O
return 0;! _3 c/ ~2 M# w8 H
}) u, D7 @. |5 N) l  O

int Push(Stack &S,SNode e)
{5 K0 m8 F( S/ m
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL); Q* X, L) N* a- x0 l$ o
      {, W% t- M% K, w7 t' T% d
         printf("动态分配内存失败!");
         return -1;# [+ L% r) |8 R/ L: `& q+ E
      }; Y$ R' @: `' {) G, c$ a
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}+ t# J% D( v& I! H4 z
*S.top=e;
S.top++;
return 0;
}

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)1 k- a9 {+ O6 A& y/ l" a
{, V' ~: b2 u/ s
      printf("栈为空!");) e6 t) V3 }  R% X4 Y
      return -1;
}4 I( \0 t3 f' U' g
e=*(S.top-1);
S.top--;
return 0;  D' s/ ~; D* |" c  Z4 i/ Q
}

char get_precede(char s,char c): A  b( _# y% N  Y! G# g
{
switch(s)
{% a9 w9 z  D$ ?5 ?% c  n
      case '+':                8 V/ F4 [5 P0 c0 ]# f1 v( g
      case '-':' w) ?, ^7 Q1 r$ \3 b0 L
         if(c=='+'||c=='-')
               return '>';; [/ }+ s* N7 d" n9 p
         else if(c=='*'||c=='/'). q+ n5 ~3 y! @  x
               return '<';$ ]' ?& m( Q4 r& d9 e/ W
         else if(c=='(')
               return '<';' ?8 l: T. ]+ c8 a; A
         else if(c==')'). |3 R  X+ D: |' g9 U2 A2 I
               return '>';# {4 }3 L" n. b7 F& m% _2 c+ N+ M, u" p
         else , I& V5 w2 X7 E& o
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')! t$ h# A" Y% k
               return '>';6 Y# H5 I& S0 ?, M' }& d$ ~
         else if(c=='*'||c=='/')( M1 j8 V9 r  r
               return '>';. p# S+ z- D  f) {- C/ K# ]
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else
               return '>';
      case '(':
         if(c=='+'||c=='-')9 `6 m0 Z0 }- y+ {
               return '<';/ I" H2 x7 X( |% `0 o
         else if(c=='*'||c=='/')7 F, f$ O" L- c1 {7 d: e8 _
               return '<';
         else if(c=='(')8 z# o; [9 s" p& d, `
               return '<';6 b( l; _" k1 B3 U
         else if(c==')')
               return '=';
         else" l1 N4 r1 N. D  d7 A" Q5 X
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';- Z  b/ t8 w- B) Y8 i! q
         else if(c=='*'||c=='/'), o7 m" M" M, G3 \( m4 R
               return '>';
         else if(c=='(')% z* ?- Z+ p# J. a: S6 n1 B  n
               return 'E';& K( d1 G0 p4 ^3 ~; w# @# E6 p
         else if(c==')')3 o; ]" }/ |1 [
               return '>';% D; z4 e# [, N9 ?4 p, G2 S
         else7 [4 |+ ~" H; d1 u: q8 s
               return '>';
      case '#':3 g! V1 }* T0 ~! Z0 g& C' G
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return 'E';
         else
               return '=';9 ~) w/ f2 Y3 R8 [( p: E
      default:
         break;
}
return 0;
}. N) h* q8 g$ N. C( n7 u; h" e

int isOpr(char c)
{7 N: ~8 L; F/ Q
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;. U" ?# Z) E$ M$ A8 i, T& \- ?
else 3 l: i" `% }! n$ O3 j# n$ q
      return 1;4 @! d) ~- o, N6 ]& F7 O
}

float operate(float x, char opr, float y)! c% c) v  A+ y  N+ {/ m/ j
{! m( t, v: u" g) I
float result;2 j6 H1 G6 v2 j9 g4 S
switch (opr). C- N( O1 N3 i3 k
{  f  M1 }4 ]/ z% ~7 a
      case '+': ; X3 N4 L$ \9 w& \& q' s
         result = x + y;3 {) R8 p2 `  @' a' {
         break;
      case '-':
         result = x - y;
         break;
      case '*': . g5 V  M0 P- M, A( a
         result = x * y;
         break;" F" A3 H! D4 M& [8 R3 c, _  c/ H
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;! |5 ^3 k9 v4 x6 E
         }
         else
         {& y7 t! v$ ]: w3 N
               result = x / y;
               break;
         }, R/ j4 `5 g1 E3 t& a
   default:
         printf("Bad Input.\n"); & B8 ?. r. W( u( x4 J
         return 0;
}
return result;# x, I* a3 A7 @$ J6 i
} 2 k1 p* T% k) P. j
! B1 Z, h4 _7 E  F
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{- H, x# C6 ?" G, ^
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;$ W3 L% B8 \5 y1 W! f* u$ P
char buf[16];0 a  U: T: b6 }3 R# j) U+ g; U
int i=0;& @7 K/ `" z1 O* p/ H  }! [; [3 z- p

InitStack(optr); /*用于寄存运算符*/+ H# |5 ]. Y: j3 T& Z# J) f
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));1 P7 ?; d0 @4 p
8 j& O* ]2 F0 N! \7 x2 H
printf("Enter your expression:");# z3 B& u( K: q) h  s, m, h

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);
c=getchar();
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/! A- M& v. N/ p# q- s
      {
         buf=c;
" O* o6 @' _0 T* d3 G$ S, ^$ j          i++;
4 v5 c# {0 t7 M+ T# b          c=getchar();
1 q, P/ r) v; f5 N) X. n. E* {! M       }
/ T& I& j; }1 s! a; o* N       else /*是运算符*/6 s6 t" T+ A4 `" T* n" U5 Y
      {
1 R( o. }6 n, G7 @' R- t: u  A          buf='\0';
+ c6 `' s, ^: ^  J& x" F& ?          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
' }7 Z1 `" k$ p          {
" V9 D7 u% u( u* `$ N  u3 D                opn_in.data=(float)atof(buf);
$ t/ c; T3 B2 m1 N3 q5 Q                Push(opnd,opn_in);0 Q& O5 [* T4 l" Y9 w
               printf("opnd入栈:[%f]\n",opn_in.data);6 Q( ^, J# X3 h' S3 q
               i=0;, q  p5 V  Q& E/ e1 n
               memset(buf,0,sizeof(buf));4 ]( a) q. Q. A. y
         }
- M% o8 k& I, z' i7 m  N          opr_in.ch=c;
( c  C2 A% N7 d# r( D          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/1 M5 a6 ]; p" R$ K/ b  `- a, s
         {+ e  d$ z, p& `+ O8 {: L
            case '<': /*优先级小于栈顶结点,则运算符入栈*/; o) V/ `- ^) z
                  Push(optr,opr_in);) S! s2 q6 A% L
                  printf("optr入栈:[%c]\n",opr_in.ch);
, r2 Z3 w2 Q# O/ o+ D: }9 P                   c=getchar();
4 x0 H9 Y, y' v& C4 ~) D. ^- q" ~) E                   break;
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/' A/ [! L* m, Y
                  Pop(optr,e);
, `. E7 ?, h' u& M* R1 q                   printf("optr出栈:去掉括号\n");
; Z2 Q# g/ O5 I9 f/ `                   c=getchar();
5 k6 ^* v3 o) \$ e                   break;' K0 B8 Y) o; `+ r3 A. ~' N
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/4 x+ f& _/ \/ X) e/ @/ t7 i/ s/ T/ d; m
                  Pop(optr,opr_t);
: Y+ Z. t- K9 a7 _0 n' w                   printf("optr出栈:[%c]\n",opr_t.ch);
1 _' D' Z3 J+ v0 e: d; K$ L0 T0 j                   if(Pop(opnd,b)<0)4 Z5 _3 ]- b8 I
                  {
. x. l' E' `1 f8 a: g& S                      printf("Bad Input!\n");
0 k& ]+ W# m8 c$ Z8 V/ A                      fflush(stdin);
" f( o. S; h3 _* l2 ~7 w3 X                      return -1;
  V: K" u2 ?) r- k" p                   }
* Y8 f! u( f$ o6 S                   printf("opnd出栈:[%f]\n",b.data);% V, _/ p( b% M- J  H8 J
                  if(Pop(opnd,a)<0); m% _( {  U# B, I* e" q
                  {
, i$ `: `8 U) ]) _  l5 u( W                      printf("Bad Input!\n");/ Y2 d: g2 b; }& D% a
                     fflush(stdin);, J9 R! }" z- S
                     return -1;
1 R+ t0 E3 L0 c2 y                   }
6 t. C9 W# t+ P$ |0 p                   printf("opnd出栈:[%f]\n",a.data);
" ^1 T4 @) S) i                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/6 n9 K5 O; ^1 @6 K+ A0 u
                  Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/  E5 Q0 `' L& g1 g: o$ o4 z
                  printf("结果入栈:[%f]\n",opn_tmp.data);
0 V! F& S" D1 t6 m) b                   break;3 p% j- u# J" o: b% |! f
         }
7 u) ?" X0 N7 c& W5 N  K0 Q       }
. S& I% H: y: [9 j       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             9 C( c* x2 P9 ]/ }7 e0 r  S, b( n
}% Z& a$ j* c$ b1 Q. w) o. N# I
GetTop(opnd,opn_tmp);
* k- E) B+ V# I0 e DestroyStack(optr);9 C. X& _! l3 u
DestroyStack(opnd);
! T1 E# f% G* B$ n+ E return opn_tmp.data;
) v* r  R8 M( D% Z% y# P; r7 @' q}
  t  @! r' m: F. Y* V) f2 l" y! ], C: e: x8 u) H" H
char *killzero(char *res,float result)# s" T3 T2 w$ Y) c4 M( R4 i, m, P( }
{
int i;# @4 W! ~+ K- ?/ M" z! g7 j

: j9 {6 _. N: N: o* o sprintf(res,"%f",result);0 A3 z. v3 y& O; E( D9 M; t; ^/ c- d
i=(int)strlen(res)-1;
- X' G$ ]$ M9 b5 {+ X! J& a9 v while(i&&res=='0')6 j) V* o. Y' a( |
{
/ j+ W8 Y- w  C       res='\0';7 |, l$ v4 m* }4 F9 i0 a4 U
      i--;
) i9 E) ]% y+ V- ? }- D9 o9 R  n  e
if(res=='.'); P' f& V8 g2 X9 W+ E4 U5 x
      res='\0';8 w6 [4 J' F3 h0 V) q
return res;4 _) h9 [4 n( v0 d: M$ {5 I/ q
}
8 Z" ]6 ]6 H2 c( j5 r. P1 y7 A$ i6 }2 d3 R! q$ k) F6 R& V
int main()
+ K( ~: R, O/ e# W{4 V! v' g5 T! w. d$ c  _4 F, x
char ch;8 q& P9 Y8 `0 b$ x+ h$ H
char res[64];
* _$ f! k  R0 K& ?' j' b float result;
2 @+ p/ ]* ]* T5 k3 m while(1)
+ ~- h# }4 v4 E' R; U5 k' [ {" p6 N. M7 K$ ]% Z* N% e$ n  {
      result=compute();% r  D) j9 y# t/ m2 }5 k% F
      printf("\nThe result is:%s\n",killzero(res,result));5 n3 _( c" Q& n8 f3 |: k, ?  K4 d
      printf("Do you want to continue(y/n)?:") ;( n( V2 Q, c5 j- i& w
      ch=getch();
8 O* l& g8 e" V5 M; s  d- Y% B( r       putchar(ch);7 |* |* ?/ w/ S! x2 S
      if(ch=='n'||ch=='N')2 L6 t" ^* [7 s# r
         break;
0 ^# C* v6 E# Y2 i" \6 ~       else
; a6 c" @: e- [' @9 ]: U' \          system("cls");, w1 X' o% X3 r5 [- z6 b) _9 |, Z
}
  e  S5 B+ _$ _" [ return 0;0 N! x( T. r% b8 a7 U
}
& e+ _) U  p, j+ C$ b* u7 g
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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