표현식 값 구하기 M

  1 #include<stdio.h>

  2 #include<stdlib.h>

  3 #define Stack_Size 100

  4 #define StackIncrement 10

  5 #define Ok 1

  6 #define Error 0

  7 #define Overflow -2

  8 #define True 1

  9 #define False 0

 10 typedef int status;

 11 char s[100];

 12 //  

 13 typedef struct

 14 {

 15   char *base;

 16   char *top;

 17   int stacksize;

 18 }SqStack1;

 19 status InitStack1(SqStack1 &S)

 20 {

 21   S.base=(char *)malloc(Stack_Size*sizeof(char));

 22   if(!S.base)  exit(Overflow);

 23   S.top=S.base;

 24   S.stacksize=Stack_Size;

 25   return Ok;

 26 }

 27 status StackEmpty1(SqStack1 &S)

 28 {

 29   if(S.top==S.base)

 30   return True;

 31   else return False;

 32 }

 33 char GetTop1(SqStack1 S)

 34 {

 35     char e;

 36     if(S.top==S.base)  return Error;

 37     e=*(S.top-1);

 38     return e;

 39 }

 40 status Push1(SqStack1 &S,char e)

 41 {

 42   if((S.top-S.base)==S.stacksize)

 43   {

 44     S.base=(char *)realloc(S.base,(S.stacksize+StackIncrement)*sizeof(char));

 45     if(!S.base)  exit(Overflow);

 46     S.top=S.base+S.stacksize;

 47     S.stacksize+=StackIncrement;

 48   }

 49   *S.top++=e;

 50   return Ok;

 51 }

 52 status Pop1(SqStack1 &S,char &e)

 53 {

 54   if(S.top==S.base)  return Error;

 55   e=*--S.top;

 56   return Ok;

 57 }

 58 // 

 59 typedef struct

 60 {

 61   float *base;

 62   float *top;

 63   int stacksize;

 64 }SqStack2;

 65 status InitStack2(SqStack2 &S)

 66 {

 67   S.base=(float *)malloc(Stack_Size*sizeof(float));

 68   if(!S.base)  exit(False);

 69   S.top=S.base;

 70   S.stacksize=Stack_Size;

 71   return Ok;

 72 }

 73 status StackEmpty2(SqStack2 &S)

 74 {

 75   if(S.top==S.base)

 76   return True;

 77   else return False;

 78 }

 79 float GetTop2(SqStack2 S)

 80 {

 81     float e;

 82     if(S.top==S.base)  return Error;

 83     e=*(S.top-1);

 84     return e;

 85 }

 86 status Push2(SqStack2 &S,float e)

 87 {

 88   if((S.top-S.base)==S.stacksize)

 89   {

 90     S.base=(float *)realloc(S.base,(S.stacksize+StackIncrement)*sizeof(float));

 91     if(!S.base)  exit(False);

 92     S.top=S.base+S.stacksize;

 93     S.stacksize+=StackIncrement;

 94   }

 95   *S.top++=e;

 96   return Ok;

 97 }

 98 status Pop2(SqStack2 &S,float &e)

 99 {

100   if(S.top==S.base)  return Error;

101   e=*--S.top;

102   return Ok;

103 }

104 //  

105 float Operate(float a,char theta,float b)

106 {

107     switch(theta)

108     {

109         case '+': return a+b;

110         case '-': return a-b;

111         case '*': return a*b;

112         case '/': return a/b;

113         default: return Error;

114     }

115 }

116 int In(char c)

117 {

118   switch(c)

119   {

120     case '+':

121     case '-':

122     case '*':

123     case '/':

124     case '(':

125     case ')':

126     case '#':return 1;

127     default:return 0;

128   }

129 }

130 char Precede(char t1,char t2)

131  { 

132    char f;

133    switch(t2)

134    { case '+':

135      case '-':if(t1=='('||t1=='#')

136                 f='<'; 

137               else

138                 f='>'; 

139               break;

140      case '*':

141      case '/':if(t1=='*'||t1=='/'||t1==')')

142                 f='>'; 

143               else

144                 f='<'; 

145               break;

146      case '(':if(t1==')')

147               { printf(" 
");

148                 exit(Overflow);

149               }

150               else

151                 f='<'; 

152               break;

153      case ')':switch(t1)

154               { case '(':f='='; 

155                          break;

156                 case'
':printf(" 
");

157                          exit(Overflow);

158                 default :f='>'; 

159               }

160               break;

161      case'#':switch(t1)

162               { case'#':f='='; 

163                          break;

164                 case '(':printf(" 
");

165                          exit(Overflow);

166                 default :f='>'; 

167               }

168    }

169    return f;

170  }

171 float EvaluateExpression()

172 {

173     SqStack1 OPTR; SqStack2 OPND;

174     char theta,c,x; float a,b; int k; char *p=s;

175     InitStack1(OPTR); Push1(OPTR,'#');

176     InitStack2(OPND); c=*p;

177     while(c!='#'||GetTop1(OPTR)!='#')

178     {

179         if(!In(c))

180         {

181             for(k=0;!In(c);c=*++p)

182             k=10*k+(c-'0');

183             Push2(OPND,k);

184         }

185         else

186         switch(Precede(GetTop1(OPTR),c))

187         {

188             case'<': Push1(OPTR,c);c=*++p;break;

189             case'=': Pop1(OPTR,x); c=*++p;break;

190             case'>': 

191                      Pop1(OPTR,theta);

192                      Pop2(OPND,b); Pop2(OPND,a);

193                      Push2(OPND,Operate(a,theta,b));

194         }

195     }

196     return GetTop2(OPND);

197 }

198 //  

199 status main()

200 {

201     float result;

202     puts(" ");

203     gets(s);

204     result=EvaluateExpression();

205     printf("%.2f
",result);

206     return Ok;

207 }