C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的., x4 t0 O' {/ |1 K
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=( T1 }3 G+ g- ?* H0 T; C
/**************表达式计算器************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>- M- U- d; o- b' n
#include <conio.h>4 K( M# ^* j& Y$ Y% x8 \0 R( a* W
#include <malloc.h>: B( r' \# B$ E- ^6 Z: Q7 M

#define STACK_SIZE 100
#define APPEND_SIZE 10

struct SNode{
float data; /*存放操作数或者计算结果*/
char ch; /*存放运算符*/
};

struct Stack{: Z$ ?$ W4 F( ?+ M3 c
SNode *top;
SNode *base;
int size;
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/3 M: L' R- [; N8 e
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/% {# K$ ?) L2 v3 w/ Z/ r
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/  a& B5 z9 m, F. a$ }( P7 ]9 K
$ ]: g7 L% M' y- e6 `, |
/*表达式计算器相关函数*/
char get_precede(char s,char c); /*判断运算符s和c的优先级*/
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/% T$ V! g- f+ o' B5 X$ Q
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/ 8 j* S3 g% R6 t6 ?9 a: {8 {9 k4 E3 ~
( }4 @# I8 Q; V" ?, I; ^
int InitStack(Stack &S)
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));8 ]4 H' ~0 ]+ X# n7 u9 S! \% j+ a
if(S.base==NULL)! ?+ O" _$ C: Q0 ]$ i2 \6 s" T+ u
{; w% [# h9 Q! |* r- S
      printf("动态分配内存失败!");
      return -1;# h1 A5 Y2 z9 X% ]
}  Y1 K$ P7 W$ t% E
S.top=S.base;
S.size=STACK_SIZE;
return 0;. y" e9 T! {' f' f
}
- \& L* d/ r$ a9 V3 k
int DestroyStack(Stack &S)
{
free(S.base);8 P" H0 R" \; A9 e! X, H
return 0;  d( E$ @- z* ]/ i$ B  Z
}
$ t* H% E5 v6 f- ?9 y
int ClearStack(Stack &S)
{
S.top=S.base;( ^0 r* s3 [! s
return 0;
}# g+ T) A: k7 o  ^* j& f: j( |

int GetTop(Stack S,SNode &e)3 N" }: Z8 ?% Q+ c/ V# v6 l
{7 ^/ [# I" B. m: J
if(S.top==S.base)
{
      printf("栈以为空!");) c/ @' g5 x2 `* N* |8 ~
      return -1;
}  l6 P, e/ |% k
e=*(S.top-1);
return 0;
}: C% _$ @- U7 @& s: E, J, Y7 C, X
+ N6 ~; ^1 _7 P9 b7 k
int Push(Stack &S,SNode e)
{
if(S.top-S.base>=S.size)% P- X; P0 N# J2 o' t  ?% H' s
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)0 T: U* D1 @0 T% d5 y
      {  D$ I' Z- H4 q
         printf("动态分配内存失败!");7 H" K; B' I6 N3 y
         return -1;
      }
      S.top=S.base+S.size;5 |& M5 G8 {2 w5 u8 L
      S.size+=APPEND_SIZE;2 k$ e8 n1 Z/ B4 y- s9 B) M
}
*S.top=e;
S.top++;
return 0;0 m' E3 T9 |- W) s
}  ]$ W0 B# T( \& S! s

int Pop(Stack &S,SNode &e)
{
if(S.top==S.base)! i; F) C) w5 }: E& f- q3 I- q
{# J( Y4 P! @2 k4 g9 ~; ~
      printf("栈为空!");
      return -1;
}" |( `+ F( g$ F; P
e=*(S.top-1);5 |% e* x# ~9 D. J
S.top--;
return 0;
}" P6 z9 t, j  L- I9 D' \, C

char get_precede(char s,char c)
{
switch(s)
{( ?  N' I0 P0 Q; i# V( g' E
      case '+':
      case '-':! G' w! M- E* j
         if(c=='+'||c=='-')( w; \5 a8 W' b; W* J6 }9 k. c! k
               return '>';% c" ]- a7 @) X4 W4 E
         else if(c=='*'||c=='/')$ w" A) G  |5 H
               return '<';
         else if(c=='(')
               return '<';
         else if(c==')')
               return '>';
         else 1 `: j9 O7 n- ]4 g3 p- [/ h- p
               return '>';/ W  r3 M- L2 F! z+ C- S
      case '*':
      case '/':) o8 ^) D* c: f5 }3 [! U+ [4 D. [) y
         if(c=='+'||c=='-')
               return '>';, e2 d. y. }( j1 x1 J" X# l
         else if(c=='*'||c=='/')$ N0 N, H9 e$ w/ ?9 m6 h
               return '>';
         else if(c=='(')  c" L, Y) g- n# E! g8 ]9 A, d
               return '<';/ q) M7 U1 i6 A4 K/ H
         else if(c==')')
               return '>';
         else2 b$ C. T2 s% r6 K$ d
               return '>';
      case '(':+ @* L) c6 r# ?: f# i! ]. ~8 z4 M
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';' V0 Y) ~' |' B& m
         else if(c=='(')7 O" G% l. A# [* N! \* P6 E
               return '<';
         else if(c==')')
               return '=';
         else
               return 'E';. h* t# y, ^) I0 z$ Z0 C
      case ')':" I- B9 U2 B8 v  o
         if(c=='+'||c=='-')
               return '>';7 x) W: b% [% f0 ~; H
         else if(c=='*'||c=='/')7 s& v9 Y: [  H" M* ]; E7 q
               return '>';$ D( j5 m+ `7 I+ x
         else if(c=='(')8 E% x3 K, t; [3 b7 T$ b" r3 G/ S
               return 'E';
         else if(c==')')
               return '>';! s% H/ U  z8 e) G2 }) t
         else: D6 p& m* @, o) m5 @
               return '>';4 l( B- z: k% T/ N7 P: \
      case '#':
         if(c=='+'||c=='-')3 A  K* p% M; m% v+ ]9 I
               return '<';+ Y0 A- U3 `- Q$ F9 V2 D
         else if(c=='*'||c=='/')# o2 W) Q  I, E! d+ t! J
               return '<';
         else if(c=='('), R6 B+ s% n1 f' F- J; P
               return '<';9 d* a, @& `4 g" z  D: n
         else if(c==')')
               return 'E';" {* k% Q- e7 t/ t1 z
         else- t& U) b  d, @/ r6 _% y) u
               return '=';2 A7 S% Z+ j) w+ l$ F; z6 e
      default:
         break;
}( L5 {9 c' W! ?$ g& u, Z7 H
return 0;
}
3 R5 k9 [  W/ h! h$ D3 M. F
int isOpr(char c)( Y7 }3 E7 }8 x0 B% D+ k1 [3 t
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')
      return 0;9 G0 r# v6 Z2 c4 O: Z
else & H% G: p3 P& \" u1 _
      return 1;$ _2 X7 c9 s6 [7 C
}
0 r. j, }( n$ f0 }4 ?" V
float operate(float x, char opr, float y)
{6 ]. @7 |( C# l0 u7 C
float result;
switch (opr)/ y8 y5 {# s% `1 E
{# f# d1 Q4 a; _8 `
      case '+': % U7 J- G$ `- {' {2 I! @2 D
         result = x + y;) r  _) [7 V6 Y& e+ X
         break;
      case '-': 4 N6 e' ?4 |6 y# W0 U" V4 n3 A; A
         result = x - y;; ~0 C# T) ]$ r9 d% y7 Q( R
         break;% z( t) y& k5 R% O* g, g
      case '*':
         result = x * y;
         break;/ Y/ N! o4 u$ F5 H5 e2 B
      case '/':
         if (y == 0)0 `6 m8 z' k; I' i9 {
         {1 |5 \1 j  a# }: e/ X7 J
            printf("Divided by zero!\n");4 O6 x* A# y) E& v
            return 0;
         }
         else. `, v) |( h+ S: E! X+ ]+ t
         {3 B& I) }: p4 ~" H  i" F4 j, y
               result = x / y;
               break;
         }! `& R: q( E1 l' f
   default: & c4 [) Q; `2 y- r" ~% j
         printf("Bad Input.\n");
         return 0;- m2 n/ D; l, _1 L% n
}. b- u/ J( z9 T$ D
return result;
} 2 d* v2 U: l% `0 O" t

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/
{
Stack optr,opnd;( b& ^* {( a) Q1 W" Z. n9 v& B
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;+ g# c4 @- w, p5 @* w5 R
char buf[16];
int i=0;

InitStack(optr); /*用于寄存运算符*/8 o6 o; @7 {2 W" ]9 ?. o
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));
- G4 o( E# h9 v7 k; }0 |: g
printf("Enter your expression:");* @; L. t) I' B$ D
      2 y, `8 \6 O' ]& r! l8 R
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);7 O! {  U4 s( i2 V6 `4 }6 E% K, j
c=getchar();1 J/ d* Z/ P* P2 ^3 @8 y# Q- `. X
while(c!='='||opr_top.ch!='#')! {( Q; e0 _9 R2 a6 k3 Y4 t! Q! q
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
) G) y( @2 ^3 ^9 Y          i++;
% n9 V( |& ^4 ~3 U4 }9 W. E: w" r          c=getchar();
- d' j) a% w4 k6 E* t8 K. x       }
( L+ ~; b1 `; Q+ Z1 x% k& ?5 X       else /*是运算符*/
( Q+ T9 f6 m- ?6 K7 m       {
4 o: Q+ }; f6 v, ]# Q3 R1 v: ~1 B          buf='\0';* b: J/ W' c3 W/ a/ [8 }* `
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/4 Q  D  S) [' a% G
         {
6 H  [) h! R: ~/ O2 A- Y' [* I( j                opn_in.data=(float)atof(buf);
' S# P; o4 s, M' q                Push(opnd,opn_in);
& `% g+ V" F4 C9 ?                printf("opnd入栈:[%f]\n",opn_in.data);: i( ?( ~4 x8 u2 K; Z) o8 Q4 Q$ }* Z
               i=0;4 }3 Z$ W$ r. f5 R1 S2 g
               memset(buf,0,sizeof(buf));
4 g. [+ c! F8 J0 x7 Z- r          }
1 A3 T& @) E& |, |( T3 a          opr_in.ch=c;
1 d: L2 h; E8 C  i) x* l0 i; _          switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
; V1 O7 X- m9 b+ f4 ~+ i7 G1 C4 M          {4 g& B% W$ B  f& w9 P( {) Y# j
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
# j) s1 l7 j8 k9 T% i5 ]                   Push(optr,opr_in);  C, H0 W  B/ e& b
                  printf("optr入栈:[%c]\n",opr_in.ch);% w8 V/ H+ c1 ]) W  q) M
                  c=getchar();* C% ?  t9 r0 V# ~+ Z
                  break;4 Q2 B+ A; G. k+ P$ y5 I
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/7 \: t+ I' |$ z0 O% k8 u* ~
                  Pop(optr,e);
1 `7 |; h" R- i1 K                   printf("optr出栈:去掉括号\n");! D+ U. u* O4 M0 E7 x& M
                  c=getchar();
  |% t4 z+ s4 Q) B6 N8 @* p5 Q* S                   break;
* t" W% Y7 |6 H( t- c5 l             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
; H# H1 |, i$ ~- B                   Pop(optr,opr_t);
" l- N9 g9 J. M7 V                   printf("optr出栈:[%c]\n",opr_t.ch);
) A0 j& O1 r, H                   if(Pop(opnd,b)<0)& P! v/ v8 `& p' ^2 \" j$ q; r$ @
                  {
9 c8 }" z, _) n( X& N7 c4 b7 l                      printf("Bad Input!\n");
! K' G3 D' q: @. a                      fflush(stdin);
% s' Y' Z* j" B4 e                      return -1;
5 s# b  X4 |% A& x" _                   }$ C: P0 [5 e) Z5 o# J* i: W
                  printf("opnd出栈:[%f]\n",b.data);
+ o* o$ |3 `/ g2 J( M* f                   if(Pop(opnd,a)<0)
8 n4 N% X) O* g" m                   {
7 r7 `( ^1 ~; F) C1 }4 B                      printf("Bad Input!\n");
$ _3 d" ?  q7 x7 j; ]                      fflush(stdin);
; ?0 i0 _) [( d1 c9 r  M                      return -1;
0 [' H5 d/ u: A1 s                   }
! e% z  F) ~" B" l  Z8 X' d                   printf("opnd出栈:[%f]\n",a.data);( K/ a* L! d, e0 }
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
1 @5 D2 Q1 E3 V' z                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/  T- W! Z* W' j& P  p5 c
                  printf("结果入栈:[%f]\n",opn_tmp.data);
$ d( \7 |) J8 d2 l                   break;3 b' O, a' \% l9 a' G
         }4 ?8 d# Y1 z( i% b+ C
      }; |% ]1 n% p' I' q/ X2 B( M
      GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/             ' W0 y  e2 F; S  F* j/ i8 {
}
1 v0 R0 h4 j* f7 f; h% b% N/ ] GetTop(opnd,opn_tmp);! T: z  O  _9 }! L
DestroyStack(optr);9 P0 z; y. `2 f. Z% ~
DestroyStack(opnd);+ a* Y5 m- G$ J1 o) x- z+ l* F
return opn_tmp.data;2 J' F3 U( x6 }3 o$ {4 P# A
}
' l" |7 I1 o4 |0 s; ^3 r' b' n5 m) E# Z# a& E5 {# F. d
char *killzero(char *res,float result); T' Y7 _/ p3 e' d3 ?# T9 j
{
/ J9 N) V" y8 ^  \7 k5 x0 d; ~* r int i;
. A* x- q( U/ x" A
% i$ t( q+ m: H7 g! Q# E5 Z2 ^ sprintf(res,"%f",result);
5 d# E  q# X6 D7 q i=(int)strlen(res)-1;
: l& L2 G( Z9 v# w5 u while(i&&res=='0')
7 C, r0 l* t2 k9 o/ Y {9 D% V) z3 P4 k- K/ J  R* x
      res='\0';
  s9 F# C" o; F; x       i--;
' J2 h, S# ^; {# }6 r: Q }
6 H: C1 i1 X! o1 R if(res=='.')
2 i# g8 \5 K% p* ?. `       res='\0';
- s2 G4 L1 e, G return res;& ?+ i0 X2 c. N  T& n- j, g) I8 p
}9 x, |8 g# @- O: t) E2 }6 y

6 B) ?' G! m& i* D" Zint main()
( i' p7 h2 j- \* o; {' @- e# l{
& G; h2 a& f& e. x/ ]8 p  \1 } char ch;' w0 p6 j: W/ Z2 n9 D4 f
char res[64];) g+ T7 Z8 u* s1 O* a3 i
float result;
/ `- a2 m# O; ` while(1)7 p. E3 |" y& j0 x8 e; r9 N
{  H/ Q% ?( {, z$ j7 e
      result=compute();
2 e# F0 P* w" d3 U( i       printf("\nThe result is:%s\n",killzero(res,result));9 E1 w. S& y  n. p& t! ~
      printf("Do you want to continue(y/n)?:") ;
) d7 j$ |7 u4 F/ ]       ch=getch();$ c+ _- A8 r# D; ^4 _9 q. }- b
      putchar(ch);5 h1 e; I' @1 \
      if(ch=='n'||ch=='N')
9 k6 o+ l4 z& o! v* ^$ O( N          break;; a: U+ T( [8 p& H
      else
  s- n$ z, Z( `3 [" {          system("cls");
) u/ |+ j) l/ e% U/ n. r }
0 d/ k  ]( ~4 ]8 @, p; v  B& E return 0;
. l1 @8 q2 a, T& F}4 o6 \1 r2 G& g8 b+ }# W# o
* ?/ T2 E3 B7 h/ Z  X( _
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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