C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.2 w8 G" @' P5 i
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=: g" I  ~9 l# @% B3 k
/**************表达式计算器************// e+ t$ h3 Y8 \0 \, }5 T
#include <stdio.h>5 Y1 v6 b4 v! j  d8 P& T
#include <stdlib.h>) R5 @, c1 T: Y/ K
#include <string.h>
#include <conio.h>7 [8 d9 b7 \6 O" Z. E# t) Y
#include <malloc.h>
# ]9 a$ k6 k( h) W9 Q" y8 `0 b
#define STACK_SIZE 100. F6 H1 b- w- |
#define APPEND_SIZE 10

struct SNode{! f) x  v/ g6 t3 |/ ]
float data; /*存放操作数或者计算结果*/6 F' k8 b4 z1 R  V; H+ k
char ch; /*存放运算符*// ?7 D( m) }& z3 T
};/ T, T6 F- \/ n( B! Y: q

struct Stack{
SNode *top;
SNode *base;6 D% P9 t5 D' `7 v0 ?
int size;/ D; H( q/ D6 O/ t
};

/*栈操作函数*/7 s& B5 `, ~1 E! U7 X
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/2 g. k8 p: Z9 a" j) j, t" ?1 _
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/! _/ g3 v1 V3 S( O% H# Y
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/+ Z. u/ Q7 h- a0 @$ d) ]; ~

/*表达式计算器相关函数*/) a' }1 c: D! A0 g" s- P
char get_precede(char s,char c); /*判断运算符s和c的优先级*/& U" k% a: {6 R! ^' Y0 w# O
int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/
float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/' o: K* n: {2 i3 T, a; g. u' A
float compute(); /*表达式结算器主函数*/! E" q+ b) H. u5 O; d, t" j& Y
char *killzero(float result); /*去掉结果后面的0*/ - t" h" q+ \- M6 ?

int InitStack(Stack &S)
{' _1 X+ ~- d! ^/ A/ D' K" [: `
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));
if(S.base==NULL)3 K4 v5 n! T! z4 M# Y! I
{/ c5 f- b+ D1 q% s; u
      printf("动态分配内存失败!");% A! f% q: N: E9 M8 i* Y
      return -1;* c; I1 |$ @3 A+ T. w
}
S.top=S.base;
S.size=STACK_SIZE;
return 0;
}
5 ?1 k& W. `- R7 a7 W- I
int DestroyStack(Stack &S)
{
free(S.base);
return 0;( c) Z! g' L$ J) r
}' K* X2 A, `# i) Q$ R# `

int ClearStack(Stack &S)# j6 d* q; E! y- ?5 I
{+ _6 X, H# \* L
S.top=S.base;
return 0;1 h" }1 X. c: @% y  X( T) Z* q% `, t
}
3 y: z4 X, b5 N" Z  B
int GetTop(Stack S,SNode &e)3 O: J* S2 N/ y3 V3 }( V) w4 s
{, ~4 Z) J' \7 p6 H$ z
if(S.top==S.base)2 v3 R& }( E5 O
{# R# Y% D& [% ^( W3 E; u
      printf("栈以为空!");
      return -1;
}
e=*(S.top-1);
return 0;
}

int Push(Stack &S,SNode e)
{- y+ T: |0 ~: e, T
if(S.top-S.base>=S.size)
{5 X  s. Q" y  V6 }+ U
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)
      {
         printf("动态分配内存失败!");
         return -1;
      }
      S.top=S.base+S.size;: O/ O! X& Q3 R! m4 K' f0 \4 A
      S.size+=APPEND_SIZE;
}8 P5 B/ J9 G0 X/ ~: v' c
*S.top=e;% C$ l( W! M* m! w
S.top++;
return 0;: Z# k2 _' J  n" N) ?
}! o( [4 c  f8 Q3 I
  r# c" n7 s* w
int Pop(Stack &S,SNode &e)
{
if(S.top==S.base). J4 s$ t8 S/ `7 q1 q
{/ S, B9 c8 ], o7 h1 J
      printf("栈为空!");8 P  z% Y+ A8 K
      return -1;
}5 h1 C7 I; q) n4 Z% y2 g
e=*(S.top-1);
S.top--;
return 0;, S. O) \, u( D! `, b8 ?
}! ]) F1 V+ v  n& E0 ~4 i3 [
5 f6 S) }, O+ z3 S" w( F
char get_precede(char s,char c)" u* B* \& k: q1 j- q4 H; b. d2 @
{; `% R8 s4 u# K- q; Q" ^+ q0 W# h4 W
switch(s)
{
      case '+':
      case '-':$ p6 L* S1 p. T; b5 M" O, |" K$ q: `
         if(c=='+'||c=='-')' d" _. C. E- b/ i# }
               return '>';
         else if(c=='*'||c=='/')( U% ]$ D  l- ]. U+ V( Z$ ^1 d/ W
               return '<';  A6 j& \' v, n$ m. `; z8 i
         else if(c=='(')
               return '<';( ^# s; I3 R: q
         else if(c==')')
               return '>';
         else 8 G- M  v; z8 P0 Y7 o! N7 {
               return '>';  d! w, y% r, h4 J5 Y
      case '*':, g4 L9 g8 s1 n
      case '/':: K1 U' c1 O- X$ x: {
         if(c=='+'||c=='-')
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')2 L' l6 H8 b; M
               return '<';4 \7 [" L' ?% h  K, {
         else if(c==')')
               return '>';2 Q8 U9 h1 S0 B9 T5 c* H
         else. K+ t+ s* c! l9 j+ H/ b' T
               return '>';
      case '(':
         if(c=='+'||c=='-'), _% B5 o$ c( |
               return '<';
         else if(c=='*'||c=='/')7 r$ I8 W9 B, l: Q# P
               return '<';
         else if(c=='(')2 O4 s# `' G5 K. \* m4 N
               return '<';
         else if(c==')')
               return '=';
         else) ]" Q; b+ H! [4 v8 p4 u
               return 'E';
      case ')':1 ^% ^7 \3 o. K& |9 e
         if(c=='+'||c=='-')7 z4 e8 e& q, w0 w9 [
               return '>';
         else if(c=='*'||c=='/')7 I+ [: G) {: Z7 {& C
               return '>';
         else if(c=='(')
               return 'E';. A0 O6 `% q! M. m
         else if(c==')')
               return '>';' q; E# w* O; ?3 U" S  x5 b# i
         else3 v. ?5 D* x# D9 P0 N5 N9 V
               return '>';0 {% E5 `$ v5 w# V  Z4 t
      case '#':
         if(c=='+'||c=='-')
               return '<';
         else if(c=='*'||c=='/')
               return '<';1 T# j  X- Z% X& S: b% `1 l7 ^% v
         else if(c=='(')
               return '<';
         else if(c==')')
               return 'E';1 |' w( B/ K% t5 f. a
         else7 p# j4 _8 u8 R+ t: c1 J2 Z
               return '=';+ b3 B8 m+ f# B" ]! h% v5 Q8 ]
      default:
         break;
}. z% d: d: V, r% `& b4 z
return 0; + l$ Z! J) S3 p8 Y- C. @! Z
}/ t1 u1 ?; M1 j* x
7 A2 m- l4 [5 B+ h
int isOpr(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')  T( l7 s' W; {
      return 0;
else
      return 1;( q6 X  l8 L/ ]/ B* P  Q
}9 s( c% B) m8 R& Y9 A; k

float operate(float x, char opr, float y)& h" h% l7 ?9 p
{
float result;1 d. a! j9 [4 M
switch (opr)
{% W2 a# ?. c& X
      case '+': # Y. e1 x% ~& R% A  h; A
         result = x + y;( S, j4 P; E5 [/ k
         break;- Y( s+ N- {4 h! r9 W3 ^
      case '-':
         result = x - y;
         break;
      case '*':
         result = x * y;' ]1 L5 T; ^* w' A/ |5 J$ t
         break;
      case '/': " Z" y4 ?$ x  o) d; s
         if (y == 0)3 x. e  d4 s, T- k& ?4 A- w
         {
            printf("Divided by zero!\n");
            return 0;
         }* ]  b5 x6 v, a7 C" G% x+ Q
         else
         {, V0 q7 n( p% G/ v8 D
               result = x / y;
               break;
         }  _  g" t' U7 Q
   default:
         printf("Bad Input.\n");
         return 0;  i+ p) B! T3 F
}1 ~/ W  |# f/ m8 c7 x
return result;
}
/ O/ o2 ]$ z% X
float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/. h; m4 A2 i3 ^1 z7 x" A- k" r" j
{$ P5 [4 n( a$ P* `
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;' S8 L4 K! C, c
char c;
char buf[16];1 i$ |+ p, r' p% s7 M1 G- [' ^
int i=0;

InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));

printf("Enter your expression:");: p* A, m' x2 X. }! u  w/ |

opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/
GetTop(optr,opr_top);3 R1 B6 Z, }( k
c=getchar();
while(c!='='||opr_top.ch!='#')+ k! {1 t. O3 o; T( y0 u+ O
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {
         buf=c;$ q5 O0 E; }0 B3 f8 L& ?
         i++;
& d8 K8 x2 `1 M7 ]' H1 I          c=getchar();( V* S  n: F6 F8 s
      }
& n  [0 E2 j* s" @& L( K. A3 B: E       else /*是运算符*/$ \2 [2 `8 I  W
      {; ]+ Q$ K- W5 d$ e; \8 t
         buf='\0';
, S! h& S: w8 z0 N  q2 \+ O          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
; `- T+ o- ?: N: ^2 |, W9 d) @3 H          {
: t* K# O& u& H# A' ^0 f: J4 k, ~                opn_in.data=(float)atof(buf);
. y1 R$ G! `" t  x& N                Push(opnd,opn_in);
' Z! i0 y8 u+ F' A' J$ D( V, o                printf("opnd入栈:[%f]\n",opn_in.data);
0 {, y2 f, \- M% \( X: _                i=0;
( s/ B4 u  V% }, j. O! p                memset(buf,0,sizeof(buf));
2 o# d% a! l7 o; w* T& s" B          }+ f  l" A9 w) h* N& j
         opr_in.ch=c;$ J( z% A, Z! s
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
1 u% }/ Y# s. t% N: Y. ~          {& P! o( ?: Z) S1 N
            case '<': /*优先级小于栈顶结点,则运算符入栈*/5 p+ {- D2 z! M1 s- ^7 N5 g5 b
                  Push(optr,opr_in);# o) s: _6 y( Q8 q8 Q+ ]* l% K5 g+ ~) T
                  printf("optr入栈:[%c]\n",opr_in.ch);
; \; ?1 ?) Z7 M0 \6 e                   c=getchar();
( F9 D/ |6 Z. r( M5 b                   break;
# c3 Q6 \' y& n. q             case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/2 f: ^) W1 e% i; f: d( [
                  Pop(optr,e);# K" U( t) y9 p
                  printf("optr出栈:去掉括号\n");7 h3 G/ y4 y1 E& `, V
                  c=getchar();4 c2 I3 ^& R9 z9 |% b/ G1 u0 p
                  break;( N8 d5 D/ L3 d/ }) m4 Y
            case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/
- W: V4 t/ X7 t                   Pop(optr,opr_t);5 D3 @" w' S$ r, ^% d
                  printf("optr出栈:[%c]\n",opr_t.ch);/ S! k: N; U$ K5 Q- `
                  if(Pop(opnd,b)<0)
! q) J5 }1 x; p" l                   {
. }7 i( I) @: E) ^. p5 ^1 Z                      printf("Bad Input!\n");. I: p  ]+ D7 ?4 w  B, z
                     fflush(stdin);1 u0 D/ M' D3 f2 M
                     return -1;3 E0 q- U6 \* ]& `
                  }
0 u6 J6 V9 _4 Q9 C7 S# x                   printf("opnd出栈:[%f]\n",b.data);
+ H( j1 K0 Z8 \  [                   if(Pop(opnd,a)<0)' y) U4 L- b$ t5 Y/ \
                  {
" e6 r/ k5 i( S! v. Q( I                      printf("Bad Input!\n");" l' D+ W) X; _% g. {1 v
                     fflush(stdin);
1 a$ B+ [  Z/ e) R: z                      return -1;  f3 n( ~0 \- w) Q+ O5 ^
                  }! b& W) P6 B- ^+ \1 u6 e: l
                  printf("opnd出栈:[%f]\n",a.data);9 y; T: k  R) c, i
                  opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
+ X4 I% A0 U9 ?" |                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/4 Y% ^  u3 w& ^% v# q6 D
                  printf("结果入栈:[%f]\n",opn_tmp.data);
2 R, i1 V3 g+ T. \! Z; U* U8 I                   break;
5 B5 X) i1 o$ K          }  L! p; u, S6 n/ b( x8 }6 Q4 V
      }
+ J, C1 a8 R& C% x( g0 Q       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
8 X/ p( O! j6 J* j. ^2 e( B }
; A  }' V4 X* \ GetTop(opnd,opn_tmp);
- V6 r0 w( J& n2 F4 X! k DestroyStack(optr);
' \  H: e( }1 \) x# e DestroyStack(opnd);9 i' f& }) d. u
return opn_tmp.data;
) i' a0 e* @0 ~}
/ t" j9 J5 Y# A6 \0 ]  {# _5 o8 ]6 }/ M6 z$ Z, o0 M
char *killzero(char *res,float result)
4 n2 g% Z2 e) u6 ?6 G2 M{$ ~; B- k2 a9 _* g' ~
int i;
  M  x6 j5 n# \) X
; T5 _& V3 |9 T: j2 P! @ sprintf(res,"%f",result);6 i# v  A3 B1 x$ A' q3 z# {' M& F
i=(int)strlen(res)-1;
" \1 }4 f( Y3 Q& s) z5 w2 p while(i&&res=='0')3 }6 M# m5 v% m2 Y
{' p( u8 ^; V+ u% ?
      res='\0';
5 z% C* D; Z: x6 T7 e. C       i--;
2 x3 N; B3 q# c/ C }
" t2 p- S: K/ w3 t2 x% p! O0 M! r7 E if(res=='.')1 M. @9 h# I+ D+ j6 I, J
      res='\0';
1 Q! P  E2 v( d return res;: W5 K: ?; ~# T; R/ |
}% }( t& W: c0 ]9 E) L2 P

, q% u( L  I% ~" g2 r" `( C2 kint main()
6 o; y0 C. ^; A0 [: v) _{
1 S; R& P4 O. z+ p' `9 D char ch;
. G0 i7 F. N+ U  H# M char res[64];
. r5 l% u: x% F- P float result;
8 _4 b  {# b. I while(1)! T; g# v6 [6 y6 }
{" J8 ?1 U0 ]! J7 E( d
      result=compute();& R1 @% M2 E" m, D
      printf("\nThe result is:%s\n",killzero(res,result));: S* C  Q5 S, J8 X
      printf("Do you want to continue(y/n)?:") ;) d" x, V0 j3 Z: L, v
      ch=getch();7 k! I0 g3 Y1 y; v( u- [+ _
      putchar(ch);
2 M. o2 E# k6 [! g8 ]7 V+ Z       if(ch=='n'||ch=='N')
9 }) d0 C5 a6 J4 n3 |% r8 z) S          break;8 y5 T, F$ i5 P. @& @* y
      else( U  m+ S3 F5 x
         system("cls");
7 I( h: U  h7 P8 I }
" c1 ^8 y6 b2 }  {1 c% E return 0;
; t8 }$ g9 h9 r" B7 y5 W" _}2 k/ Z  {+ `: a! Q

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

返回列表

C语言表达式计算器

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

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