C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.6 e6 [* A  N2 Y  u2 x
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>* S) t/ ^+ z2 a9 c' }
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>

#define STACK_SIZE 100/ z3 D( P. G: @- d- E) ^0 d
#define APPEND_SIZE 10) W  J4 @' r+ p- R0 z
( c, y9 O' I$ j  B% `7 Y
struct SNode{
float data; /*存放操作数或者计算结果*/! ~; r. o  x  ]' D9 w) n
char ch; /*存放运算符*/
};

struct Stack{# z. K7 w+ F6 Y$ z1 s; u5 o- e- F
SNode *top;
SNode *base;
int size;$ A$ Z7 X4 u7 X, Y( z
};
$ J9 Q# V( e, h+ M; p
/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/' J. j" {3 e3 f  \# U$ n
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/) h8 \$ A5 a8 \5 \' e
int Push(Stack &S,SNode e); /*将结点e压入栈*/, C8 s% h  Z& @
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/' l8 A8 X! V( g6 u/ g$ h

/*表达式计算器相关函数*/7 _$ Y, y8 x3 ?6 T
char get_precede(char s,char c); /*判断运算符s和c的优先级*/4 |3 [9 G4 X) |9 E0 I
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/
float compute(); /*表达式结算器主函数*/3 S3 w* \* Z4 O4 Y" V
char *killzero(float result); /*去掉结果后面的0*/ ; Q! L# Y; M5 t( I& u
% o+ G% n; D7 E1 R. q" K
int InitStack(Stack &S)2 s6 V3 K! n4 @: j" p7 G( U) f
{
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)
{
      printf("动态分配内存失败!");
      return -1;; n" d# w) i1 y
}/ ]  M" C9 R: Z6 f. C1 S) X
S.top=S.base;( b; T+ [' D' ^: N4 F3 f- m" A5 M
S.size=STACK_SIZE;
return 0;
}* {+ z; i- n+ W

int DestroyStack(Stack &S)8 s" F$ k3 i$ Y1 k
{8 j3 Y' o& `" y6 \6 {
free(S.base);
return 0;2 M6 H# G! v: V: O8 l( ?# d; Q+ T
}
4 B7 g6 o; {8 o; @4 g3 F% B
int ClearStack(Stack &S), h* _* e0 \% m7 n
{
S.top=S.base;
return 0;
}

int GetTop(Stack S,SNode &e)
{
if(S.top==S.base)4 @8 p- {6 o8 {4 V2 F1 c! x3 H
{
      printf("栈以为空!");
      return -1;* D, N4 _  F+ `
}
e=*(S.top-1);
return 0;
}

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));
      if(S.base==NULL): m5 R; U! m, C; U9 Y# x
      {0 n. w: ?* y# N/ f  w# B
         printf("动态分配内存失败!");
         return -1;/ d0 V! @' Q! t$ \0 [+ \
      }
      S.top=S.base+S.size;& z. p- j1 s* P$ G- n
      S.size+=APPEND_SIZE;
}
*S.top=e;
S.top++;$ H: N* E) O9 F) I' I, p) U
return 0;$ Y8 O. I/ i) z3 d- A; p+ C
}
$ S4 Q0 j# u  K
int Pop(Stack &S,SNode &e)
{; z* K# `' u& I+ w0 H  q
if(S.top==S.base). n  L  a& V' A& r
{
      printf("栈为空!");4 P/ S8 l8 x$ l( b/ h
      return -1;2 K) S/ p- N) A( ~  _& q3 \0 O
}+ L! @+ d7 O1 n( @
e=*(S.top-1);
S.top--;
return 0;2 }% |% @+ I1 P) O3 j: l/ B! i
}: Y9 G' `8 q* f  d3 [+ r0 N7 \1 `

char get_precede(char s,char c)
{
switch(s)0 S% H" x8 \& u0 R+ ~1 \
{4 S7 U# x( f1 i& Z" [
      case '+':
      case '-':! [* N( b5 z$ l* d  U/ B' _
         if(c=='+'||c=='-')' G. E/ I* r! v; Y
               return '>';) @, d. D# K6 j, R
         else if(c=='*'||c=='/')' r( L" n6 n0 J6 ^( O( D
               return '<';
         else if(c=='(')
               return '<';+ H# O, l; z5 F- u
         else if(c==')'). S' e4 ~$ m& j
               return '>';- [+ Y* v& ]; C) B/ o
         else ! s* _' t5 V. t9 Q& s: Q0 P
               return '>';
      case '*':
      case '/':
         if(c=='+'||c=='-')% O( X: \" F* X% V7 H
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')3 I* l+ ~! e9 i- `# v4 j
               return '<';. E- q  C% m: V% l
         else if(c==')')
               return '>';
         else' r  e: m6 t) C- y: |% m
               return '>';
      case '(':
         if(c=='+'||c=='-')
               return '<';" C0 Q# K1 F9 x3 X" G" O  _: b
         else if(c=='*'||c=='/')$ B% e9 d/ U, W- G7 E1 Y/ [
               return '<';
         else if(c=='(')+ M) d+ P$ ~/ I) q6 I) `
               return '<';
         else if(c==')')2 {" c8 G. x/ M4 ?( Q4 K
               return '=';/ `% [7 K7 n. Y: I" x( j# n4 J
         else
               return 'E';
      case ')':3 N6 v- M9 O/ K. L2 Y
         if(c=='+'||c=='-')
               return '>';2 H% F' w. H4 `: a* n. L
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='('); A$ x1 P' n+ y7 g7 u
               return 'E';) I: P+ f) S& r+ _
         else if(c==')')
               return '>';
         else5 O+ ^( s8 z! z7 k3 [  p
               return '>';& i  N  d7 b  j/ y# ]0 Y
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')8 O% V9 C1 Y% D; `
               return '<';' t9 t* n7 V0 Z( G0 x/ T* }" s
         else if(c=='(')5 n/ D, ~8 F/ |$ I1 k
               return '<';5 D! `2 x4 D2 G- u
         else if(c==')')
               return 'E';
         else
               return '=';
      default:
         break;
}
return 0;
}
' `8 A9 Y) ^7 d8 s3 I
int isOpr(char c)" k; E2 l9 O0 E' _
{, ~" }' _6 k' j. j/ J/ v0 I. @
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')& b, b$ _: v- Z# n0 W1 T. G
      return 0;
else
      return 1;/ {. v$ k, J% y6 m" I: G5 ^( n" X4 X
}

float operate(float x, char opr, float y)
{
float result;
switch (opr)
{7 c3 v& ]8 x  j5 k% h( Y, p
      case '+':
         result = x + y;! T# D& ]$ @" H' O' A7 T: Z
         break;1 Q1 {1 n- D0 R, A
      case '-':
         result = x - y;6 a7 ]( T/ J- ?
         break;
      case '*':
         result = x * y;
         break;
      case '/':
         if (y == 0)
         {. Q8 q# M9 c: w( g6 f8 w* q
            printf("Divided by zero!\n");4 r6 _5 F% H: u, k3 A/ D) {. R
            return 0;& \0 z, z- s6 Q
         }0 z; a& V& _1 @1 U9 x
         else. W( |; f. ~: W' k+ H' _( K
         {; S7 l  \1 V% L' S1 H
               result = x / y;$ l! v  C" e3 P3 u0 R9 y# U+ N
               break;
         }
   default:
         printf("Bad Input.\n");
         return 0;# q/ \4 I% `) f, @; `8 E
}
return result;; m' q! s$ b) c6 c$ D
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/8 ]2 |8 z5 W6 A/ _
{/ o$ D( \( ?* @5 |0 n- V
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;1 h! L' h6 o+ X+ \+ H; K' y
char c;
char buf[16];  h6 H6 O" j' O- @$ }$ f
int i=0;
' x' G; ^: K4 Q% c/ o" j2 p
InitStack(optr); /*用于寄存运算符*/; l( w9 q7 e. `! W* @7 d
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));) a5 k8 g/ w  ?( }) {$ X+ J
$ ~* Y; a/ w) V( }, L
printf("Enter your expression:");+ t+ n! b! R4 g3 [! _

opr_in.ch='#';8 E% [* ?7 A, K  j/ V' Q: a$ U$ ]
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);1 v3 o- W, B: l
c=getchar();
while(c!='='||opr_top.ch!='#')0 d; P" y! B- f0 |' E" @" B2 A
{9 k7 }' t, c+ b) Q* K5 H
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;
3 V& R, l! a7 I/ y6 v          i++;; }8 n# ~- s, S: o  i4 r
         c=getchar();- _& z5 q! U5 c. S& Y
      }0 P+ ?$ U9 T# M* T+ ^1 I
      else /*是运算符*/) R0 t7 o6 [$ X2 k7 S# R# L
      {
, ~. Q: K" w  w          buf='\0';8 z: ]: s+ |9 v$ w
         if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/) r4 I5 l( B( D7 \
         {5 L  J5 u& T4 ?: e) a6 k) h/ E
               opn_in.data=(float)atof(buf);8 M7 j! J) f6 V
               Push(opnd,opn_in);
+ v! i% [3 X: y% q                printf("opnd入栈:[%f]\n",opn_in.data);4 Y+ W2 J* p" c; S* O8 F) R, `5 G
               i=0;
. V1 O) [6 U" B( R: p  O5 [: T                memset(buf,0,sizeof(buf));# g9 W9 C- H1 C9 C3 N
         }) g& ]: J6 ^& n3 \. H4 a! o
         opr_in.ch=c;8 H' h0 j3 ^; D9 i+ O
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/. P. G5 V! y9 W0 V* \- s
         {! }* L" }+ x2 S: v# a1 f5 h9 H
            case '<': /*优先级小于栈顶结点,则运算符入栈*/
7 s9 r( B; t* N                   Push(optr,opr_in);
* [" f# e' k8 ?5 z1 h' _                   printf("optr入栈:[%c]\n",opr_in.ch);  q& |$ b4 w' _7 ~" `: u4 C
                  c=getchar();$ o) c2 F+ I1 I+ f5 X, S* @
                  break;* z" a. l: ~# o4 `) ]
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/
0 V2 Q4 ]% s8 T1 i( T+ B                   Pop(optr,e);
' c8 p0 Q+ D! d& `5 q- E1 h                   printf("optr出栈:去掉括号\n");
+ Y$ X5 g3 d: B, |                   c=getchar();; P2 N4 X# d6 Z3 r# ?
                  break;
2 s- N8 M& O1 P6 ^( u1 g             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/0 g; L" N6 C- `7 C  E5 Q
                  Pop(optr,opr_t);
                  printf("optr出栈:[%c]\n",opr_t.ch);
) F$ n9 n8 g: h; c8 q! ~                   if(Pop(opnd,b)<0)) I% _$ o& K; J9 r  R+ K. f
                  {  m2 s6 s: d1 A: E" d
                     printf("Bad Input!\n");: \" u1 ?' p0 t& n; a3 K2 m( ?
                     fflush(stdin);
2 f6 ?4 H+ k# ]$ y, B! P/ w" k                      return -1;
. l6 k9 a  u* T# l                   }
1 K8 j) D+ [. G                   printf("opnd出栈:[%f]\n",b.data);
" t2 V5 P" f3 ~7 A. A: ~# e8 l$ L                   if(Pop(opnd,a)<0)
3 p/ j) g9 B0 }; w+ y( ?                   {
( o! B5 F1 [/ U2 O7 @                      printf("Bad Input!\n");/ J4 H0 {; y4 G1 k+ {
                     fflush(stdin);6 p: G+ S0 D1 B! X* ]* o
                     return -1;
0 e3 W+ Y, C! O7 P0 G2 L3 ~                   }1 j) Z2 \# h9 f. h' h
                  printf("opnd出栈:[%f]\n",a.data);. c# F* H0 F: F* a/ X8 G
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
& X- D0 Z( k/ P3 z( W$ H                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/. x  S  n3 {0 b9 [# K
                  printf("结果入栈:[%f]\n",opn_tmp.data);- o" S, i1 k) R" a
                  break;9 ~" U6 g, c1 k; T' L: c# J& w' B
         }
9 T" p' q" g/ R: J       }
$ E! }4 _: s: G; Q       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
1 y) L1 \6 I0 ? }
/ C+ R% k' \* `- l' g5 b. }: |  H GetTop(opnd,opn_tmp);
$ {. [8 i) m, E9 L2 k DestroyStack(optr);
. Q$ W( z- |7 X DestroyStack(opnd);* `+ F: T' x# v( Q0 {" P, k, G# ?5 N' M
return opn_tmp.data;
6 \- K5 ]# T% ]& g1 j0 i2 e" P. l: S- y}
+ F/ c/ C; p( W- {9 G! k" d' a+ N5 n5 [  |# Y- I( f4 c( f# h
char *killzero(char *res,float result)0 v( H8 k# O% _0 d. Y
{
. T( N) k: K. g* M int i;3 S$ w) d0 Y2 X2 ^+ b6 z' W( a, N
( D% s* G# }. \3 ^' j
sprintf(res,"%f",result);) X" u4 S" d3 z1 Z8 t3 r& L
i=(int)strlen(res)-1;
% Q0 ]9 U6 E$ a5 S. z while(i&&res=='0')
6 @0 a% G6 A, O, S8 O$ U {+ j, c) Z- e/ h: R+ O9 h2 W. B7 [
      res='\0';
* w% z) }. \# W4 h       i--;
  k( u0 I' J- ]- p+ k; Z, [0 [ }1 m; [' O7 g. @9 Q( I
if(res=='.')+ s- p: x3 a' n" X; z2 s
      res='\0';
/ }+ Q0 u, P5 {8 ^% S" y, b return res;  L0 C0 Y( [; O! b. f% N# b# A
}
4 V5 j7 P% _8 j/ r1 q/ j
, C+ u( j& o3 ~" iint main()
) @' Q/ `, i7 H7 w- s{
5 G3 C8 B  U3 D# f char ch;
; {" }2 d! ~( @! a; B char res[64];, }1 _+ W% ]: O% Z" w
float result;; A! z: k7 e# b3 E% ]6 @
while(1)6 ?$ {6 `" u8 ~. p
{
4 i+ J) r# ~5 S5 O9 k; Z       result=compute();- I) x* [8 S* ]+ i
      printf("\nThe result is:%s\n",killzero(res,result));
, P$ H1 F$ f1 Q- `' k       printf("Do you want to continue(y/n)?:") ;3 Y3 ]+ S$ j6 @4 n
      ch=getch();
* q1 q/ ^3 o& a4 X, p       putchar(ch);  J9 x6 Q+ \: q$ S) L
      if(ch=='n'||ch=='N')  l( T3 b6 h6 {: u* X4 f
         break;
% f% W4 A) A  @       else+ a, [' k, K3 P) Y& W/ F9 n
         system("cls");+ n3 B' u# q2 m6 L8 J* p# }
}
8 _' f" y& v  c4 n: Z return 0;
+ y( ]* M+ M, }( o/ \9 v  y9 `$ G}
4 V2 J, [! d  F# ]; x
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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