C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.% o( y$ p" V6 Y% z& u. o
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=! n- I: K2 |9 q( j9 S3 J$ k2 U. l
/**************表达式计算器************/7 d5 Q3 D) R  r6 ?! I
#include <stdio.h>
#include <stdlib.h>" Y2 T; H; }* V
#include <string.h>
#include <conio.h>- Y- O. U) F" u! C+ |$ a
#include <malloc.h>" J, D5 h6 D0 y* l. s5 {0 r

#define STACK_SIZE 100; X  N7 x/ Q- d: k, n* p  A+ ?
#define APPEND_SIZE 10& p/ [9 C4 U  _7 ]
7 M8 u: T, D! V4 _
struct SNode{& g0 U2 X2 S: M& }& X/ i
float data; /*存放操作数或者计算结果*/7 E0 E6 g% Y$ O  V: t
char ch; /*存放运算符*/# z  y7 a6 e( `  ~9 r6 }0 O
};
" U# U6 D9 U) p; [$ R
struct Stack{4 f. q$ \3 z! C* ]; {' {/ i
SNode *top;, ~4 z& B& n" M$ A- q4 C
SNode *base;& y6 S3 ?  o; t9 O: z8 C  d( y
int size;
};/ ~$ S+ F. C  \$ d! h: `, H) {7 H, H
9 s$ T# E. E; ]' a+ u+ N" A2 [
/*栈操作函数*// A3 J7 ?- u% Z, N! O3 ]
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/) e) E' o3 s0 m2 A9 e; d, O: M
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/2 G3 t+ @6 c8 O! C
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/
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计算后的结果*/6 n3 B, k; ]+ h8 b
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/

int InitStack(Stack &S)0 `5 j" r) E& |$ ]  b0 }
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;% I9 S, @/ v/ T) r4 m4 P
}* i+ j. e3 @3 d* f) Q# C% e5 E; l
S.top=S.base;4 ^2 `* o! Y0 h" U! k- @
S.size=STACK_SIZE;
return 0;
}
! y; _7 W3 V/ F% X# l- k% U- P
int DestroyStack(Stack &S)
{
free(S.base);
return 0;+ l; _' \/ e) V( h3 ^$ |" c
}

int ClearStack(Stack &S)5 }+ Y! j1 u8 o2 i) K! l
{, F4 W$ L$ N/ J. _: n( }
S.top=S.base;' C6 {6 V" ~" Q4 ~" K
return 0;
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)# K9 M! l' d5 m8 M
{
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);
return 0;
}/ h; p3 e# y2 j$ o

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));1 A% f% @9 p$ k# s8 r% K  b
      if(S.base==NULL)
      {( {# G8 F8 H" V% D: D8 B
         printf("动态分配内存失败!");- u" l8 i) L+ C: }1 ]% _* Y
         return -1;2 O& E0 b6 e% b& D/ V& }- C% ?
      }
      S.top=S.base+S.size;3 J# h. `$ V: l( P* u9 v
      S.size+=APPEND_SIZE;
}
*S.top=e;% v; O+ z( D  l: B! y3 x
S.top++;
return 0;2 U8 K6 n- g% p9 ?4 j
}; M5 f8 `; a- C7 ?" ^; \

int Pop(Stack &S,SNode &e)0 z) s% e8 u: v
{
if(S.top==S.base)( @6 Z9 i( P# m, e; s' T2 ?
{0 m, w9 r- j9 m9 l' I+ P+ q: a
      printf("栈为空!");( q' h" M! a" d* f" C  o- ~
      return -1;3 Q- l% R; J6 m3 Y
}5 A7 \: }' W2 M( ^& J! M- a
e=*(S.top-1);
S.top--;- C5 v0 Q; p8 h6 R* T; ?! B3 S
return 0;
}
* v' B2 f) H& z3 O$ I, b& X* ]
char get_precede(char s,char c)
{  p, v: q. J. y1 J- _- x) Q* g
switch(s)
{
      case '+':
      case '-':
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '<';- c7 l+ q+ O, ]6 [  M1 i
         else if(c=='(')" E9 V9 m  i$ n, ^
               return '<';
         else if(c==')')4 M6 p% |* B2 y/ Q
               return '>';
         else
               return '>';& H- j. A" `3 @( d4 Z+ i
      case '*':+ W. ~, I" T, P2 c' ^
      case '/':9 w- J# d& k. a
         if(c=='+'||c=='-')
               return '>';- ^. t. t( a9 X) Y3 S: {: a
         else if(c=='*'||c=='/')+ ]6 ?" j2 f) w% L3 l; O
               return '>';" {0 o# X9 q% c1 L" l) _$ S
         else if(c=='(')
               return '<';
         else if(c==')')/ ?! J8 N% N( t
               return '>';- I& f) k" a8 I; K6 O, x! n( q
         else
               return '>';
      case '(':; j8 O. I$ }: n3 R, e6 a0 ?
         if(c=='+'||c=='-'); \+ L" W( R' h  Q+ [5 ]. r! q
               return '<';7 D5 O8 O: b) B$ {# X5 T% }
         else if(c=='*'||c=='/'), d* p( P3 h6 o! [0 K! B
               return '<';4 ~9 l: K0 t2 Q8 b( w' e; L4 \; i1 W
         else if(c=='(')/ C6 l5 V3 c% |! T0 p
               return '<';
         else if(c==')')
               return '=';
         else
               return 'E';# i& D2 Q8 p6 g  W7 ], }
      case ')':3 w. S- y2 h( ^; h2 ~/ T' V% y$ a4 z
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')* h& l) }' C; `5 q, I% j/ k; z
               return '>';. w6 Q8 }0 ]9 [5 h( Y7 [( h3 o* \
         else if(c=='(')
               return 'E';
         else if(c==')')! J2 c3 V: D; d7 ?
               return '>';
         else
               return '>';
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';0 v0 a1 z7 S+ v, L: e  g2 \% W
         else if(c=='(')
               return '<';
         else if(c==')')
               return 'E';
         else8 |& ^/ Z$ N: C( r3 R5 G, D- {
               return '=';3 ]* A) A" T5 _% O" S* t. f7 ~+ _& [
      default:
         break;
}4 |) n& l# z  G
return 0;
}& n2 T) {& ^/ L! [  K: e  H

int isOpr(char c)
{+ s9 Y' s# U* E" a
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;
else 5 ]* @1 G$ ~- e0 }4 E5 S( N
      return 1;
}& s  a; ]3 f8 t8 K; w# s' \, A6 e

float operate(float x, char opr, float y)
{
float result;5 J1 j8 X- n7 r6 _1 ]4 C3 K
switch (opr)
{
      case '+': ( E7 \/ U) F- g( Y2 x1 Y
         result = x + y;& y1 {) ^- u: h! }/ i+ v% B9 w9 o
         break;
      case '-': 8 J3 j$ v2 M/ \
         result = x - y;/ C7 {! p8 f4 j, i# m
         break;
      case '*': 4 l; E% P  J' \5 y7 c0 t" Y
         result = x * y;
         break;/ ~2 o8 r7 a7 r, f1 R) V9 D  C5 S
      case '/':
         if (y == 0)
         {
            printf("Divided by zero!\n");
            return 0;
         }( _' [, d: M8 {
         else
         {
               result = x / y;
               break;8 ^# Z+ C% O$ q3 j, R
         }
   default:
         printf("Bad Input.\n");
         return 0;; w) t- n, z7 b2 C" I3 H+ S
}
return result;2 n4 F: {- t( S1 r7 b9 W/ {; a
} * \3 j7 g! N1 I$ H0 U4 |

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{: C$ a5 s$ y4 o; n. u* A/ G4 H
Stack optr,opnd;- x5 G8 m8 |) }2 m2 d5 P+ G, k) }
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;1 t4 q# G! ], K! O- m" P1 C
char c;1 E6 Q+ A6 R2 ?. Q  @  W. s  S: m
char buf[16];6 v& ?  A: s! j9 t
int i=0;
+ A* }4 m: C3 p4 e& S* q% [6 S
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/+ g+ L! M# Z& n- R* I- [# d  I
memset(buf,0,sizeof(buf));
. f6 l' g2 q% E$ l% N) p& y, ~
printf("Enter your expression:");

opr_in.ch='#';0 `2 i9 L! T1 K; ~' {. {/ J
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);# {& U: Q5 H0 E- ~) ]/ Y
c=getchar();
while(c!='='||opr_top.ch!='#')+ B* |5 a. J7 J6 J4 }0 ]
{. a; S( e% w+ H6 E' l; J
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/) y+ _. [, m. K: F% H/ S0 v. i9 D
      {
         buf=c;
/ G. C  Q2 }* O& C) N          i++;4 P) |& Y% C1 V( r
         c=getchar();
7 j8 h8 R( [1 n& s       }
& p* @: j  _1 y! ]! h* ]       else /*是运算符*/
& g! r# S, _* W& A. M       {
$ ]1 x* @- w0 F          buf='\0';+ y0 h4 W8 T. N7 M& a
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/, n  l/ t8 e/ z+ g+ y
         {
: A+ V! d+ d  X7 P                opn_in.data=(float)atof(buf);0 T: B) @. f; h0 b
               Push(opnd,opn_in);1 ]* F$ l1 `3 L% q' l
               printf("opnd入栈:[%f]\n",opn_in.data);8 y, i2 I7 y/ D1 A. ^# u
               i=0;
" t( P7 [7 ]* }$ r5 x6 u                memset(buf,0,sizeof(buf));9 \# ^+ P% M: e1 O6 H& I
         }
2 c& r8 i* K- k3 t          opr_in.ch=c;1 |9 ]: x+ _1 B+ x, A
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/0 S( y% M: E0 @1 U& _
         {  `  n  i' d8 N! {0 R
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
/ [( d( g5 h3 o% t( ~  a0 t& s# y                   Push(optr,opr_in);
* r& j( F7 v: j( [# z1 K; H                   printf("optr入栈:[%c]\n",opr_in.ch);6 Z" O2 W+ ~; H/ w3 |3 h5 R+ \
                  c=getchar();
+ k; B$ Q, S, c, l                   break;; Z6 a0 m' a+ T- {
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
1 g6 L/ O; g, E9 X                   Pop(optr,e);( B0 |' e  h2 D$ r  _' J5 [* D
                  printf("optr出栈:去掉括号\n");
) Q/ ?2 T5 v2 E# T5 N9 h                   c=getchar();- m% }/ E. K8 ?+ m* R
                  break;3 O( \6 p+ D0 f7 J# Z1 c& F
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/& L# f) a) y: [
                  Pop(optr,opr_t);" C$ U1 H* p6 Y
                  printf("optr出栈:[%c]\n",opr_t.ch);: Y) Q. o4 ?3 x: q# v
                  if(Pop(opnd,b)<0)5 W5 y: k0 _, Z( Q
                  {0 w% Y9 |7 L) E1 J0 G6 A
                     printf("Bad Input!\n");5 W7 \: A5 f+ C
                     fflush(stdin);
5 e1 n) p) m% {                      return -1;
- X0 R$ c( x4 G; y' S                   }
+ x, I+ K1 h! \. v% {+ y# ^                   printf("opnd出栈:[%f]\n",b.data);
; [& Q/ l. c# e: `7 L" r                   if(Pop(opnd,a)<0)4 m3 c. s# d# T
                  {7 X& b" \: \4 d  ?0 H
                     printf("Bad Input!\n");$ u- h7 a. a7 Y9 ^* [" N5 [- o3 n
                     fflush(stdin);& F. |/ C  M# c3 _3 h4 q  p4 F
                     return -1;
' d' Q. s; c" s; [9 u                   }) d2 L* m% L: }5 ~( S4 N
                  printf("opnd出栈:[%f]\n",a.data);
1 e0 Q3 }1 O/ E" Z0 l# k5 {1 l4 A                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
* k0 g9 n# p; R, k                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
! }+ l) F, e/ y! W                   printf("结果入栈:[%f]\n",opn_tmp.data);
* `% W9 q4 O+ L& F7 p                   break;
8 `" l( M) ?" j7 r          }
  r4 R) W/ h4 q0 I. Q       }
! W8 [; z5 |6 E' A, ?       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             6 w4 k2 ]# r0 H5 m
}6 o3 r  c% L- {1 l( b; l& S& T
GetTop(opnd,opn_tmp);
. D4 }$ G$ L# t9 i( ^6 j7 } DestroyStack(optr);) D. Z. y0 V9 V/ L. M
DestroyStack(opnd);
' \; n- ?- w: a( |. r: B2 M% S0 g return opn_tmp.data;  c, G3 j) \. }: V( F/ N% d+ C
}
2 X# ?8 I0 U2 o4 R4 e. @0 h  M
/ \0 H% h' c* z' gchar *killzero(char *res,float result)
/ n2 m- d" S) r1 f{
* B: d# m* h4 [ int i;9 x+ T. r. h" V2 c7 L' f

- ]' f7 p# s$ o/ X% { sprintf(res,"%f",result);& {; F. ^0 f/ s; z- }. K' C! A4 b
i=(int)strlen(res)-1;
8 \+ Z8 f4 K' v* H. Z' Q! E) l while(i&&res=='0')
8 q0 H( P/ D' g) t9 e6 T {
# A9 F' Z+ o& Y2 E3 Y' N3 x2 G       res='\0';
* i% }/ C0 I% k. A( N' `" B7 Q       i--;
* b2 M- f/ }2 a. m- F }
& \) |. \7 s" [+ ] if(res=='.')9 o7 D) h* E9 @; t0 t. L- U% h
      res='\0';8 u$ r9 X2 _5 B7 B! M: d
return res;
, J! w+ ~  z+ S% G* ~1 p}
0 G- K. g( H2 p3 U( A$ y% L
5 w, m# p8 @% Y% o& K& ~* W" pint main()
, h, [1 J1 ~. N. C{
8 U/ r: k& E8 f1 J" q char ch;
) y) C8 l1 r# P3 U% Y char res[64];
* x: f% P0 r3 H float result;
. b6 f9 p5 k# I9 T% D! z while(1)8 M1 ~) N) p! E$ V
{
1 _! c( G8 [1 {2 A" {2 J       result=compute();
2 {/ E3 ^* m9 i, J& [4 |       printf("\nThe result is:%s\n",killzero(res,result));3 [( h$ r/ ]+ j3 t& S  V" G
      printf("Do you want to continue(y/n)?:") ;
: W# T; _6 U# Z1 z8 a' V; o       ch=getch();
( p% r9 V1 J. h$ @* J) l       putchar(ch);3 n4 t% F% I+ X( _
      if(ch=='n'||ch=='N')
  y. b* M' A" Q) {          break;* y) Z  O6 R% J3 {4 P0 f2 Q( N
      else
: Q/ {( Z# m2 _! \2 B) E          system("cls");/ C; L% {9 u1 _9 ?4 u6 c, `
}
  A4 f9 Z) n3 c# f* |% s) G return 0;
; T) X  R7 h% S; T" L& o9 E}

[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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