C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.* S# M/ \* P! u) H6 g% R2 r. O' f
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/, {. ~0 C" ^! P" K; Q1 X  z+ s
#include <stdio.h>
#include <stdlib.h>& |% s: `9 Q( t( @$ |; g, F
#include <string.h>( z/ v9 F! L0 X$ c5 Z
#include <conio.h>
#include <malloc.h>! ~. T* C5 n+ F. s

#define STACK_SIZE 100
#define APPEND_SIZE 10, }5 z- j& d4 S; c: o$ a

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/8 l! r: W, }# v/ }' ^8 g9 N
};: O/ l* h; l! \) D

struct Stack{
SNode *top;) i( E+ c! Q( W
SNode *base;3 p$ ^$ `; Z5 T, F% n
int size;8 Z: |8 {: ^* F
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/( d( R, H4 ]; m7 l
int ClearStack(Stack &S); /*清空栈*/+ G5 P0 s" K, {1 A; {9 h9 W, {
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/2 T. _8 v: @) c. r6 a$ C
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/& X, y" z2 F2 ~6 {# @

/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/& N7 ]+ L4 `4 l& ~. p
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/, i7 i$ C8 t; ^' g
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/. E4 D# N3 m6 b  c# j6 S
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{7 c8 {) p) r2 D* M& S3 g8 x
      printf("动态分配内存失败!");* t7 ?# E2 v" V' \. X
      return -1;+ l0 {# X' q- a. e
}0 J* k, p* R* j0 W2 c7 ~
S.top=S.base;
S.size=STACK_SIZE;
return 0;
}

int DestroyStack(Stack &S)8 C  n# c0 C" z5 q4 z
{
free(S.base);
return 0;7 J. `6 V3 g3 P/ H8 y0 `2 e$ O# \* K0 c
}

int ClearStack(Stack &S)5 h; O! }5 E" z: l; w
{
S.top=S.base;0 J' @9 J; D: b  k+ r: @; Z. O
return 0;
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base): E+ h6 w+ ^5 p; W4 Q
{
      printf("栈以为空!");6 ^) k2 h; O6 k
      return -1;
}
e=*(S.top-1);/ j- K- o3 H! C
return 0;3 l+ W5 V* z1 X; k5 H, h( N
}9 {* g5 P( z* ?8 |) a3 X+ X

int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));" f& g! y" J0 O4 e
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }4 H! v$ a8 O9 J
      S.top=S.base+S.size;
      S.size+=APPEND_SIZE;
}
*S.top=e;
S.top++;% w3 y4 z" H" B3 \3 K! e
return 0;
}. G3 H: N# D; F! s7 L2 T
& G: {% c  L$ W$ M9 a9 q
int Pop(Stack &S,SNode &e)  v4 z. y8 @: E9 |
{: M: G" ?0 r* F% [
if(S.top==S.base)
{
      printf("栈为空!");
      return -1;8 J8 T' y/ x3 X
}
e=*(S.top-1);
S.top--;
return 0;
}% w) {9 u, |  \$ ~

char get_precede(char s,char c)+ j% f. f- X' \% ~- t' p9 x$ `
{0 f- G! F! O; H: c; o- G  m
switch(s)
{
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';; P) @- q. ~8 Y+ y
         else if(c=='*'||c=='/')4 c" R) J2 g: P+ q6 }  }6 V" o
               return '<';
         else if(c=='(')) l6 J- J3 m: l2 a# P3 a
               return '<';4 u0 \) _) _2 V4 G1 e: M9 ^
         else if(c==')')
               return '>';$ @9 R- ]- E& h- P% e! q: `; K
         else
               return '>';7 K: [1 T) s6 Y  c
      case '*':
      case '/':
         if(c=='+'||c=='-')4 `) v4 Q, J2 X' |* d5 t0 N* F' a
               return '>';, p" e( ?, w# y* @$ y* q
         else if(c=='*'||c=='/')
               return '>';# B' D3 W' a. ]4 V% c* M
         else if(c=='(')
               return '<';" W* F0 i! ^% b  {
         else if(c==')')
               return '>';
         else
               return '>';
      case '(':# P! g  A2 j4 }$ G& n" c8 r& n/ r
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';- U- Z, o0 Q, ?5 a5 U% F3 y% _
         else if(c=='('); i; q  I& M2 G0 ]5 a3 L
               return '<';
         else if(c==')')
               return '=';
         else$ n( N) \1 Z& |
               return 'E';
      case ')':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';4 B9 p9 Y* o. E( u1 W/ L0 X: N
         else if(c=='(')6 |2 [: w0 A9 `  S3 j
               return 'E';
         else if(c==')')1 \/ \; ]* y9 u7 V( x& n! P1 A  o
               return '>';
         else! A' q6 O! t) Q& ]& Y
               return '>';
      case '#':; }7 _( o% m4 ~% T$ W
         if(c=='+'||c=='-')! m% |9 O$ J. g7 h( B- h
               return '<';
         else if(c=='*'||c=='/')6 x# E" i- R7 u' F
               return '<';, _: W1 o+ q4 a8 D
         else if(c=='(')
               return '<';
         else if(c==')')4 ^. v) a& j" U
               return 'E';
         else
               return '=';
      default:
         break;+ D/ y# F& l6 h: n3 v1 ~3 Y" g9 C
}0 Q5 i' J' f# [9 t! [2 n
return 0;
}

int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')2 `$ u! B5 d8 e/ Q$ U
      return 0;0 x' O, W( \# R* u1 h, K1 y# V. e% s1 k
else
      return 1;
}6 _) _. P9 Z' l* Y$ w

float operate(float x, char opr, float y)8 O2 y, M  e3 ^$ S
{
float result;) u! a( y7 _5 h
switch (opr): {3 G( ~" k# G& P/ o
{6 o6 [  p/ T8 g5 M( w
      case '+':
         result = x + y;+ w: y& v/ D% Z! [2 U2 X7 d1 g
         break;
      case '-':
         result = x - y;
         break;% j" Y  {& w/ k
      case '*': 9 k* d7 m0 k& s
         result = x * y;  R# q$ `* G$ ^+ B
         break;
      case '/':
         if (y == 0)7 ?4 N& x0 M3 t3 L# l5 O1 f. O" Z
         {
            printf("Divided by zero!\n");
            return 0;
         }
         else4 n5 \5 G" x* h6 C
         {
               result = x / y;
               break;
         }8 _  W1 V5 B+ t  y
   default:
         printf("Bad Input.\n");
         return 0;
}$ q9 ?( _4 q5 \) Z" B6 k; y
return result;
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*// z3 {9 B& K9 u
{* R7 W9 R9 m* ^
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];
int i=0;
4 S5 l# ]& Q% R+ R, d$ c( r
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));% Q. ?+ b" w9 _1 ^$ q1 a% L3 ^

printf("Enter your expression:");

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/2 x2 U" U, S5 {4 b* l
GetTop(optr,opr_top);$ x. ?3 S1 g& R: l( i5 i
c=getchar();- E' I! N- ^$ B& s4 o
while(c!='='||opr_top.ch!='#')/ ]* a) E6 p( |
{9 v/ }; R0 J8 A' `4 B# C
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
; ~; u; s6 {) Z/ x% j/ y: j          i++;
1 h* I7 b6 `, ~; p; L          c=getchar();
- Q# |9 w8 }6 Q' ]* A1 c       }9 L& m8 |' f: O5 g# y' D
      else /*是运算符*/. I0 z; }6 }' N# X
      {- ?' ?  q/ r" W/ v4 H
         buf='\0';
4 w* a% r8 f; T  Q' P# t          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
$ U( r8 f7 M) A$ [$ ~          {; b$ M# W& T. y2 \) ^+ a( Z
               opn_in.data=(float)atof(buf);
0 }  r  ^% r- X/ r, Z                Push(opnd,opn_in);7 a% [; ~% m; T: ^; @6 i9 S# y7 o! L
               printf("opnd入栈:[%f]\n",opn_in.data);- y: y$ [+ i2 u, S: y9 P9 J
               i=0;3 S6 r9 E( E  g  f5 n- Z
               memset(buf,0,sizeof(buf));
5 E3 q; J* G! X& D- F          }
" D" H: c- l8 u          opr_in.ch=c;
7 A- O8 c  c9 G) E) b          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/$ I% D# Y" W* t2 j5 j% n5 ^
         {3 p" W% I% C8 @# P$ i3 G/ r
            case '<': /*优先级小于栈顶结点,则运算符入栈*/) P5 L' m! o# }
                  Push(optr,opr_in);
: a+ D4 q1 K$ p4 i6 e; m                   printf("optr入栈:[%c]\n",opr_in.ch);: `  f: L3 H. m8 u
                  c=getchar();7 \- e+ c4 h9 D3 I# i/ r' R
                  break;+ ~" K/ O9 v3 \1 ?, A5 N
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/( x+ I8 J1 h8 S# n
                  Pop(optr,e);5 W3 |- i, W3 Q3 l2 }) z1 K
                  printf("optr出栈:去掉括号\n");
% C% h" N% o; F, m' ^4 }- e5 k                   c=getchar();
# B) o4 v: G: L! h( n# F8 {                   break;
' J. `3 j4 }8 d  a9 t' }* {             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/; f5 M  y3 [2 H8 ~
                  Pop(optr,opr_t);
5 W  b  w- x) c                   printf("optr出栈:[%c]\n",opr_t.ch);8 K1 X" ~6 x& G4 `
                  if(Pop(opnd,b)<0)
; n4 b/ K+ `5 L) V7 x8 w                   {
6 I! w5 Z/ ~( r: l                      printf("Bad Input!\n");
* R5 `8 o, I, Y5 K0 P1 s                      fflush(stdin);
7 ?6 |& t! Z$ w/ j* k" j                      return -1;  e* N, O1 g+ J0 W$ ?7 z
                  }. z: S+ }( Y7 Q
                  printf("opnd出栈:[%f]\n",b.data);
& Q2 s& @5 a( Z- Y2 N                   if(Pop(opnd,a)<0)- w% `( k) N+ }+ b3 P# s5 n
                  {0 G+ ]; a' h3 O8 t) p
                     printf("Bad Input!\n");
/ o8 g2 T  ^! [) Q  O                      fflush(stdin);
  v& S1 V) s% i                      return -1;
- ?7 N* x, p( O: q. b                   }
8 X3 c" q' W7 x* Z                   printf("opnd出栈:[%f]\n",a.data);9 A0 a2 L% Y" ]1 v0 q  A, i
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
  i  L' E5 Q+ P, p$ l' z! a                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
: C$ z% i1 t* \: V: Y  F* x                   printf("结果入栈:[%f]\n",opn_tmp.data);
9 |1 }; }9 ~) f! A4 w                   break;4 M5 ]( S" `- h& Q, i0 Q/ s/ a% P
         }$ V3 a( \# r4 M& d) Z
      }
. [) U8 f  F+ `! K& o4 [6 e# G       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ! m! c4 Q" l% s
}
+ k% h( o; Y8 L! d" ^ GetTop(opnd,opn_tmp);
- ~! ^  Z; r- ]/ F! K- L DestroyStack(optr);
9 Z8 P& L# E8 [5 m DestroyStack(opnd);* ]) g) g! B9 J' a+ p& B  H
return opn_tmp.data;
+ d/ P5 p' f5 M- |( }' y}4 X8 h, J9 f) S. d

; x9 d8 {" p. }& b% l4 echar *killzero(char *res,float result)
4 F. g1 A' a; W) Q{2 y: K8 D2 S6 o1 Y
int i;! A) k% I3 m  }0 }9 X& k+ {
4 g# o5 p# A0 d1 @  Y5 ^& _  o9 f
sprintf(res,"%f",result);7 F( S( V% O. {& H2 {0 N
i=(int)strlen(res)-1;/ g) S/ V+ s" ~5 q# {7 x! Y/ i
while(i&&res=='0')
6 t" T7 x! I! }% o( L# {  q; ~ {; ^  R( E& t. ~" ?$ _% B; O0 W
      res='\0';
* f, p/ y( s  B, i  B3 _       i--;3 k% s# p/ F- h, _
}* }( }" a+ |# o
if(res=='.'). s- ?7 x! v; Y4 A+ c" |
      res='\0';
- T+ w: \, ]- y  L9 h return res;
3 [+ s) A- g/ i}
1 ^' U+ s+ _5 u! B
5 m2 a' N0 ~# ^int main()
( M! E+ Q7 g( B* r{+ J8 M7 R2 L7 Q) X$ z; s
char ch;: z( _  Q. u* Z% O3 j
char res[64];- F$ o! T# S4 V% t5 i* a
float result;$ x! x: W  D  Z; g' x$ ?6 D
while(1)
, v: i/ W! R; F {# C3 T, P6 P+ v" u; c" X
      result=compute();
5 X3 ]4 S; m& E) _       printf("\nThe result is:%s\n",killzero(res,result));6 ?0 b5 |- l* V+ F4 J, M
      printf("Do you want to continue(y/n)?:") ;
1 L, S$ H! e4 m# f       ch=getch();; z" S' q! G4 [- t0 u9 G
      putchar(ch);8 _  ~) y8 H8 o" p
      if(ch=='n'||ch=='N')
4 Y1 A1 z) x2 m( a& w$ l          break;% u8 F( R2 g. P- \0 R& A; f! ^# k+ q' {# ]
      else8 X7 c6 n, v5 E  H, W, O$ m
         system("cls");
! w- a) U. R1 P }( t; e1 H" C& g. w2 {* I  A0 v
return 0;# s/ y) @) `7 k- ^# z" M9 X* X
}9 w  w; m& R- n/ N
0 O: K! _$ g5 F, d
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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