C语言表达式计算器

为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的.0 k2 d3 v! O$ I+ J! V+ S
程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
/**************表达式计算器************/
#include <stdio.h>* g' D- j+ F5 g
#include <stdlib.h>
#include <string.h>
#include <conio.h>( l* q" I% Z! N; j& n- g% o7 E# `
#include <malloc.h># g& [3 ^" }% _, J- p+ g

#define STACK_SIZE 1000 Q* Q* N/ r$ q
#define APPEND_SIZE 10
! z0 ^6 p- Z# A3 I' I! E, e  V
struct SNode{3 w8 Z2 e# C* o
float data; /*存放操作数或者计算结果*/# a. g: A/ m$ s/ |
char ch; /*存放运算符*/
};" r0 H( Z, h7 v! t5 G

struct Stack{! Z7 Q9 a/ o3 ~6 `% u! b& ^' J
SNode *top;9 f7 E" j) W9 i0 I
SNode *base;
int size;2 D" v" c; ?$ T% {
};

/*栈操作函数*/
int InitStack(Stack &S); /*创建栈*/
int DestroyStack(Stack &S); /*销毁栈*/
int ClearStack(Stack &S); /*清空栈*/
int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/
int Push(Stack &S,SNode e); /*将结点e压入栈*/
int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/

/*表达式计算器相关函数*/3 w# R7 E5 r/ [2 K9 T
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计算后的结果*/. F. s5 i8 W. H$ e& m
float compute(); /*表达式结算器主函数*/
char *killzero(float result); /*去掉结果后面的0*/
% O/ ?- m6 v. N) y
int InitStack(Stack &S)
{/ v- p0 b; D: p! Y
S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode));+ P2 m- E7 H0 b
if(S.base==NULL)" M8 b- k9 Z* i  o9 @) @9 B
{
      printf("动态分配内存失败!");
      return -1;# @3 W: `8 O2 @: T
}
S.top=S.base;. u2 z, x. G  j) w4 A$ i: z3 \
S.size=STACK_SIZE;
return 0;! v7 n1 w( f; }
}( J$ o# T* c4 R. u6 H

int DestroyStack(Stack &S)
{
free(S.base);
return 0;
}
* V$ P& d5 x: f" y$ {5 Z
int ClearStack(Stack &S)
{! `$ ?0 P) x1 `. Z6 q
S.top=S.base;8 f& {  n8 f  E% n, y( s
return 0;% `6 K! R# r  A- [
}
+ S* G$ b7 o* L/ s
int GetTop(Stack S,SNode &e)& j7 s+ U6 [9 d8 k8 H
{
if(S.top==S.base)* S8 n1 l3 q5 V% u, L$ v
{( R* o$ A: M6 Z9 v5 M
      printf("栈以为空!");, B' V% j! j, ?' n8 [& w, U! i
      return -1;
}# S* E; ]* n. N: R
e=*(S.top-1);% O- K1 T' e9 f: v# C
return 0;
}/ w, F3 W2 e+ t- k7 N* G

int Push(Stack &S,SNode e)! y6 @* p0 A/ @3 p5 {
{
if(S.top-S.base>=S.size)
{
      S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode));
      if(S.base==NULL)* W+ C0 `, O+ L5 F
      {( f4 \# U+ g2 J/ I8 j
         printf("动态分配内存失败!");- Q/ D3 h3 H0 O& G3 X
         return -1;' r4 c5 g9 n% l* a, a3 i. f$ B
      }- F# Q( g9 R. \, e  H
      S.top=S.base+S.size;. F* ?+ I6 b% v
      S.size+=APPEND_SIZE;, ]! ]) ~4 w7 N+ `3 t
}4 q, [2 W" e$ a6 a* ~
*S.top=e;
S.top++;
return 0;6 C& {0 W& H8 I8 E, h5 E8 O
}

int Pop(Stack &S,SNode &e)" P# u, [: I" K6 C8 z8 o" A3 f6 c
{
if(S.top==S.base)
{% `: Y( A' d1 e4 r; i
      printf("栈为空!");7 s$ s" K6 M+ Y4 [+ Z1 P" A
      return -1;
}
e=*(S.top-1);
S.top--;
return 0;6 K/ B) y: Y6 ~
}

char get_precede(char s,char c)2 p* C9 Y# `) f& v; U3 b
{6 s& f. F( B: D! F
switch(s)2 }( L' y  n- r9 k3 J4 k
{
      case '+':
      case '-':- h, T9 s7 O& B- m" q8 [
         if(c=='+'||c=='-')' s1 _% t6 o4 Q1 h1 X. |! d
               return '>';, ?5 `) x! q  [
         else if(c=='*'||c=='/')0 [5 f6 j8 x0 K& c( n" F7 d
               return '<';
         else if(c=='(')0 m* U( L  Y$ a$ E/ K5 R! _7 v7 O
               return '<';
         else if(c==')')3 b4 J* z( d0 u; J; V& U; }  k' _
               return '>';" _+ M2 @: ^- k  O. A
         else ) C+ F; Y8 g% Q3 v" n( f6 @1 m
               return '>';& V7 P2 r# M5 K& z! f9 e; l
      case '*':: E: C5 U5 ?/ o; T1 ^3 N" Z, h
      case '/':% a7 |( G. e2 d5 ]; Q0 q
         if(c=='+'||c=='-')( k' j1 {& G# R7 {" @1 P9 V+ L4 m
               return '>';
         else if(c=='*'||c=='/')6 Y4 \* A! p+ V: Z
               return '>';: @5 l, ?& R4 K- V( E' }  T
         else if(c=='(')5 E9 L; z& U/ O8 k
               return '<';
         else if(c==')')
               return '>';" Y# P9 B5 u: x3 k% J6 Q: v
         else2 I. _/ M* ~2 e& u
               return '>';
      case '(':' n" k2 S5 G5 c1 ^
         if(c=='+'||c=='-')& x3 M' h% O) U" n
               return '<';
         else if(c=='*'||c=='/')1 N0 O! c$ t, ~) f, `, O" r
               return '<';3 ^4 ^3 P* S  R3 b6 K- N
         else if(c=='(')
               return '<';
         else if(c==')')& G# `9 l. q# M; l) F5 v) |, m' [
               return '=';
         else5 H/ s3 C# `7 S! i- k/ Z
               return 'E';' S$ [- O6 a' n9 b& K
      case ')':0 U; B2 ]2 H' ~! \
         if(c=='+'||c=='-')& T1 Z6 q2 [# k) s- e
               return '>';
         else if(c=='*'||c=='/')
               return '>';
         else if(c=='(')9 }- K% A$ F" v* E0 V/ F3 {
               return 'E';% E/ i: L4 ]7 J
         else if(c==')')2 Q2 U) W' g# h: G* E
               return '>';
         else# D" T, o2 ], e/ M4 ?( l) ]; y
               return '>';
      case '#':
         if(c=='+'||c=='-'), Z  F) Y, q$ O7 ]6 y
               return '<';
         else if(c=='*'||c=='/')
               return '<';8 q$ Z* c+ b% r
         else if(c=='(')
               return '<';: y6 l* s% s: @! R4 J
         else if(c==')')
               return 'E';
         else
               return '=';
      default:
         break;
}& r# X; X  v( {. y
return 0; 2 a' G  k* T: r  U7 i
}/ ?% S8 w( d0 h$ L4 o4 E) c
" x8 X. w0 z8 _' @# |, O/ N
int isOpr(char c)' V5 b9 I: o, s! q4 X% ~0 q
{8 C5 ~! R6 N6 O$ a9 J
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=')4 ]  x+ F0 B7 J5 J5 z  I$ a
      return 0;  X4 q6 o5 i) \% ]0 ^# U
else
      return 1;
}; [. d6 h% z& X
0 f6 \+ C/ L4 R! q6 S. B% g
float operate(float x, char opr, float y)
{
float result;
switch (opr): o# k& r  c0 V8 @* z
{
      case '+': 1 {' l+ X$ w. N: D- }  {0 }1 w! j
         result = x + y;0 K' q+ u% x! |! K3 K! {1 U
         break;
      case '-':
         result = x - y;
         break;
      case '*': & c& u5 H8 A  _0 t/ H
         result = x * y;. _, v3 f7 @; X3 J; o
         break;' ]# P4 |) Z2 i) z+ Z4 d7 f. K, c5 S
      case '/':
         if (y == 0)$ c/ ^. v1 Y) {* b3 g/ O
         {
            printf("Divided by zero!\n");, n7 `& f+ N; Z# A  h
            return 0;  |/ i1 Z- v* @* [
         }" v5 r9 P# N+ i. N
         else
         {
               result = x / y;
               break;  d- A' [; z, P& Q4 H
         }2 @, B1 ]8 t8 z' C( U9 i# `
   default:
         printf("Bad Input.\n");
         return 0;4 B& U1 ~) V" W' {  C7 B* S
}/ w! N1 `& U) p
return result;% _* o, O: O8 p, }! j$ m
}

float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/( k( R5 o. _. X/ {
{) |4 ?! L* g! K' e$ D0 A* K$ e
Stack optr,opnd;
struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t;
char c;
char buf[16];. v. Y8 f) r( L$ q1 I2 }
int i=0;: f, x# q) }: l& c' J- y3 Z) l
" x' P" u8 e, ?$ Z
InitStack(optr); /*用于寄存运算符*/
InitStack(opnd); /*用于寄存操作数和计算结果*/
memset(buf,0,sizeof(buf));/ U$ Y6 T% ^3 m

printf("Enter your expression:");+ d; p- H0 K; X( a3 s( y5 q
      * {" r$ e0 c4 l
opr_in.ch='#';
Push(optr,opr_in); /*'#'入栈*/7 Z* z  [% a7 Z
GetTop(optr,opr_top);
c=getchar();" u, V+ O- y8 l+ H! p5 S4 U' X: l: F
while(c!='='||opr_top.ch!='#')
{
      if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/
      {. K/ g6 S7 p* }2 p( }; F
         buf=c;4 v7 P  g8 z9 t5 M5 X1 a& R# G! G$ U
         i++;
5 l- t- ~  V0 t0 M: j& Q          c=getchar();8 @# G5 q1 x7 d. ]
      }/ L  k1 P2 C8 t& |7 a2 s7 j
      else /*是运算符*/
      {
0 U' y0 h! ^6 m# W: l5 F          buf='\0';
- _( T, S/ g; w( a4 k7 k          if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/
" `! {( |$ k- @' d7 O" b          {; j# j1 x) x0 Z' b1 b
               opn_in.data=(float)atof(buf);
6 _) V( a# ]" ]4 ]" t% l                Push(opnd,opn_in);% }- F( O0 u8 c
               printf("opnd入栈:[%f]\n",opn_in.data);
- S, m+ E7 Z8 b2 m                i=0;( c' I! f" Y, [' M
               memset(buf,0,sizeof(buf));
  u* K' G% V# H. V$ X) t, _          }
  T5 V* c; L& L: Q7 x0 |9 l          opr_in.ch=c;; n3 I# F- X8 d6 R( W4 M$ b
         switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/
         {) h9 l( p# B+ {1 T/ h/ y, c
            case '<': /*优先级小于栈顶结点,则运算符入栈*/& M; D8 v# }# U+ Y7 Y* K) z
                  Push(optr,opr_in);
- b! D2 m4 y! t" D- I                   printf("optr入栈:[%c]\n",opr_in.ch);" {) k# n' w/ i7 p% g
                  c=getchar();
* H) P1 L7 |3 h" z0 e7 m                   break;, z( c% C' }4 s7 u' H: O
            case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/% o( O% b8 @  c7 Q4 T% M1 L
                  Pop(optr,e);
1 ^4 q5 H+ L, X+ q/ y  l                   printf("optr出栈:去掉括号\n");
0 S& h# A+ V% }2 N( D                   c=getchar();
( [# ]+ j' D* _3 ?                   break;
/ Z1 t0 L$ O0 N& o) g8 S             case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/4 n3 F1 @  g3 B
                  Pop(optr,opr_t);, a3 @; h  M/ |# S9 \+ V
                  printf("optr出栈:[%c]\n",opr_t.ch);% Z! k% @- K% o$ I6 n
                  if(Pop(opnd,b)<0), }1 n; T/ _2 X* z. Z3 r
                  {& ?; _7 N! y9 a% c1 Y
                     printf("Bad Input!\n");8 S6 w. T) ~( |$ ]
                     fflush(stdin);
3 T; W. t( ~0 U1 P                      return -1;' V6 A' Q: ]$ k* Y- @, |, |
                  }
  h8 _# w0 k$ f4 ?- \# f                   printf("opnd出栈:[%f]\n",b.data);) X3 i. |, g3 a& E# S8 O
                  if(Pop(opnd,a)<0)$ M; e$ V' N8 I( Y* t
                  {
" A1 C! u5 F/ v" a- F0 _                      printf("Bad Input!\n");
+ |  t1 q7 P# T) y' q5 J                      fflush(stdin);( W4 w' ]: u" D3 j% N2 m! E3 @
                     return -1;+ M' i) A1 A+ s. E' J, w
                  }7 s! c1 g& u$ C: f
                  printf("opnd出栈:[%f]\n",a.data);
- p, z* m# o8 e( H% P                   opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/
/ d2 i. I3 e# N                   Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/
' Q2 E% s7 ~7 ^, |. E5 y                   printf("结果入栈:[%f]\n",opn_tmp.data);! [/ _% R' Z0 z/ E) A) C" n9 g
                  break;
8 M( B0 K/ E' R: d: e2 N& }' s          }& R7 k6 [. D% y+ Z7 O5 n+ a
      }
7 ~9 t- {) C% o" g9 J# X0 {       GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/
5 n; b, M9 ]) Q2 m5 d& Z) _/ t }
2 J3 e7 T- B0 o$ O GetTop(opnd,opn_tmp);# h0 ^% b& s: |
DestroyStack(optr);. H% g* E+ d* e
DestroyStack(opnd);& @" `' A& B1 y/ C; T6 @/ U
return opn_tmp.data;
* x# E, f( P* p' A, P3 D5 i8 g& t}
, J2 a6 u# M9 M! i1 u2 H
# P& L9 g: T( X- c7 }char *killzero(char *res,float result)$ l* T& x) x- j) n  l. u
{
- d3 e$ f5 N3 g8 J2 Z3 D5 v- B& L int i;2 i4 ?* Q' ?# B2 a& P- p7 f" e
2 z9 [* E: x- j" o4 j. G2 e" V7 b
sprintf(res,"%f",result);! ^2 C' \* S6 Y( a# L
i=(int)strlen(res)-1;
6 [9 w7 |; ^# k. J while(i&&res=='0')
( U4 H/ v6 \3 ]3 F  E2 Y {
0 }; z" p; {% q  M( f& [       res='\0';: Z; \9 y4 d' j# ~/ Y
      i--;( W8 ]  z) S1 |: V  A$ G
}& j. |* D1 [- h
if(res=='.')6 C) Z  s' w+ Q* M# F+ c
      res='\0';6 G# n  T7 u( a4 o6 W
return res;7 o9 c8 R' V1 p# V7 ~. Y0 e3 A8 y$ _
}
  V: B$ [% _" J9 C: I
0 q0 u- m5 |* s3 @int main(). @1 s/ ^. z( p+ V) M$ N
{
0 Q, Y0 Y' B, d8 R4 f char ch;
! N% j/ m* A* h7 @+ v char res[64];3 T  j+ u/ x# ]* {. D+ V
float result;
8 Z( X- X( q* W+ S' l  A while(1)
/ s: \+ ^% z2 O9 j {* y4 p- {; b/ \- r6 d( T3 w2 B
      result=compute();
* d+ k% a  f0 O0 X' l4 e! q$ }       printf("\nThe result is:%s\n",killzero(res,result));
! Q5 }; O! P" k       printf("Do you want to continue(y/n)?:") ;
- j  n( t( x8 d* H! i       ch=getch();1 S4 V3 Z: }9 a; [9 ~# r
      putchar(ch);
  f# Z3 o9 L  i( H+ ^  _       if(ch=='n'||ch=='N')
4 {5 M5 Z8 b1 p          break;" ^  B( ~" J! j
      else
, b4 a8 v, y, `$ d  w7 g          system("cls");' y- h/ z5 i+ \' m8 k3 Z
}
# l" Q% F/ b, q2 T4 e- q return 0;4 }. x6 i$ A# l9 K8 |. U
}  ~  U5 K$ U! J  g6 s
) e6 R' f2 E4 U, j3 T6 S
[ 本帖最后由 zw2004 于 2008-1-21 17:21 编辑 ]

返回列表

C语言表达式计算器

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

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