C语言 算术表达式

     算术表达式的计算在我们日常的运用中是十分广泛的，特别是对于基本的四则混合运算的表达式。在我们习惯的计算表达方式中，一般来说是 中缀表达式类型的。
     中缀表达式的计算比较复杂，它必须遵守以下三条规则：
     (1) 先计算括号内，后计算括号外；
     (2) 在无括号或同层括号内，先进行乘除运算，后进行加减运算，即乘除运算的优先级高于加减运算的优先级；
     (3) 同一优先级运算，从左向右依次进行。
    
     中缀表达式符合我们一般的习惯，但是在计算机的计算中，它实现的时候比较复杂，要考虑的因素比较多。为了方便进行计算，我们可以采用后缀表达式来进行计算，因为这个类型的表达式更符合计算机的口味吧（这个是 波兰科学家卢卡谢维奇提出的，扯远了:-)）
     //计算公式 中缀表达式转后缀表达式算法

1. int Offpos(char *str)
2. {
3.         if (!str)
4.                 return -1 ;
5. 
   
6.         int pos = 0 ;
7. 
   
8.         while (*str) {
9. 
   
10.                 if (    ('+' == *str) ||
11.                         ('-' == *str) ||
12.                         ('*' == *str) ||
13.                         ('/' == *str) ||
14.                         ('@' == *str) ||
15.                         (')' == *str) ||
16.                         ('!' == *str))
17.                         break ;
18. 
    
19. 
    
20.                 if (((*str >= '0') && (*str <= '9'))
21.                         || ('.' == *str)) {
22.                         pos++ ;
23.                         str++ ;
24.                 }
25.                 else {
26.                         return -1 ;
27.                 }
28. 
    
29. 
    
30.         }
31. 
    
32.         return pos ;
33. }
34. 
    
35. 
    
36. //转化为后缀算术表达式
37. char *Prase(char *datas, char *str)
38. {
39.         if (!str || '@' != *str)
40.                 return NULL ;
41. 
    
42. 
    
43.         //假设用来处理符合的堆栈
44.         char symbol[1024] = { 0 } ;
45. 
    
46.         char *value = NULL ;
47.         char *sign = NULL ;
48.         value = datas ;
49.         sign = symbol ;
50. 
    
51. 
    
52.         int pos = 0 ;
53.         char c ;
54. 
    
55.         *sign++ = *str ;
56.         *value++ = *str ;
57. 
    
58.         //处理一些负数的情况
59.         if (('@' == *str) && ('-' == *(str+1))) {
60.                 *value++ = '0' ;
61.                 *value++ = '!' ;
62.         }
63.         str++ ;
64.         c = *str ;
65. 
    
66.         while (*str) {
67. 
    
68.                 switch (*str) {
69. 
    
70.                         //@字符串结束，弹出所有的操作符
71.                         case '@' :
72.                                 c =  *(sign - 1) ;
73.                                 if (c != '@') {
74.                                         sign-- ;
75.                                         while (*sign != '@') {
76.                                                 *value++ = *sign-- ;
77.                                                 *value++ = '!' ;
78.                                         }
79.                                 }
80.                                 break ;
81. 
    
82.                         //'('符合进入堆栈
83.                         case '(' :
84. 
    
85.                                 *sign++ = '(' ;
86.                                 break ;
87. 
    
88.                         //弹出到'('为止的所有符号堆栈里面的字符
89.                         case ')' :
90.                                 //to do ;
91.                                 sign-- ;
92.                                 while ('(' != *sign) {
93.                                         if ('@' == *sign)
94.                                                 return NULL ;
95.                                         *value++ = *sign ;
96.                                         *value++ = '!' ;
97.                                         sign-- ;
98.                                 }
99.                                 *sign = 0 ;
100.                                 break ;
101. 
     
102.                         case '-' :
103. 
     
104.                                 c = *(str-1) ;
105.                                 //如果  '-' 的意义表示负号
106.                                 if (    c == '-' ||
107.                                         c == '(' ||
108.                                         c == '+' ||
109.                                         c == '*' ||
110.                                         c == '/') {
111. 
     
112.                                         *value++ = '-' ;
113.                                         break ;
114.                                 }
115. 
     
116.                                 //如果  '-' 的意义表示负号
117.                                 if ((*(sign - 1) == '@') || (*(sign - 1) == '(')) {
118.                                         *sign++ = *str ;
119.                                         break ;
120.                                 }
121. 
     
122.                                 //弹出所有的堆栈符号
123.                                 sign-- ;
124.                                 while (!(('@' == *sign) || ('(' == *sign))) {
125.                                         c = *sign ;
126.                                         *value++ = c ;
127.                                         *value++ = '!' ;
128.                                         sign-- ;
129.                                 }
130. 
     
131.                                 sign++ ;
132.                                 *sign++ = *str ;
133. 
     
134. 
     
135.                                 break ;
136. 
     
137.                         case '+' :
138.                                 //+符号不做那么严格的处理了
139.                                 c = *str ;
140.                                 if ((*(sign - 1) == '@') || (*(sign - 1) == '(')) {
141.                                         *sign++ = c ;
142.                                         break ;
143.                                 }
144. 
     
145. 
     
146.                                 sign-- ;
147.                                 while (!(('@' == *sign) || ('(' == *sign))) {
148. 
     
149.                                         c = *sign ;
150.                                         *value++ = c ;
151.                                         *value++ = '!' ;
152.                                         sign-- ;
153.                                 }
154. 
     
155.                                 sign++ ;
156.                                 *sign++ = *str ;
157. 
     
158.                                 break ;
159. 
     
160.                         case '*' :
161.                         case '/' :
162.                                 //这两个的符号优先级别比+-高
163.                                 c = *str ;
164.                                 if ((*(sign - 1) == '@') || (*(sign - 1) == '(')) {
165.                                         *sign++ = c ;
166.                                         break ;
167.                                 }
168. 
     
169.                                 c = *(sign - 1) ;
170. 
     
171.                                 if (('+' == c) || ('-' == c)) {
172.                                         *sign++ = *str ;
173.                                 }
174.                                 if (('*' == c) || ('/' == c)) {
175.                                         *value++ = c ;
176.                                         *value++ = '!' ;
177. 
     
178.                                         sign-- ;
179.                                         *sign++ = *str ;
180.                                 }
181.                                 break ;
182. 
     
183.                         default :
184. 
     
185.                                 //默认数据值压入堆栈
186.                                 if ((*str >= '0') && (*str <= '9')) {
187.                                         pos = Offpos(str) ;
188.                                         strncpy(value, str, pos) ;
189.                                         str += pos ;
190.                                         value += pos ;
191.                                         *value++ = '!' ;
192.                                 }
193.                                 str-- ;
194.                                 break ;
195. 
     
196.                 }
197.                 str++ ;
198.         }
199. 
     
200. 
     
201.         return datas ;
202. }

    计算后缀表达式的算法

1. //计算公式
2. float Calculate(char *str)
3. {
4.         if (!str)
5.                 return -1.0 ;
6.         if ('@' != *str)
7.                 return -1.0 ;
8.         str++ ;
10.         float datas[1024] = { 0.0 } ;
11.         float f = 0.0 ;
12.         float *temp = datas ;
13.         int pos = 0 ;
15.         while (*str) {
17.                 switch (*str) {
18.                         case '@' :
20.                                 break ;
22.                         case '+' :
23.                                 f = *(--temp) ;
24.                                 temp-- ;
25.                                 *temp += f ;
26.                                 temp++ ;
27.                                 *temp = 0.0 ;
28.                                 str++ ;
29.                                 break ;
31.                         case '-' :
32.                                 //处理负号的问题
33.                                 if ((*(str+1) >= '0') && (*(str+1) <= '9')) {
34.                                         f = atof(str) ;
35.                                         str++ ;
36.                                         pos = Offpos(str) ;
37.                                         //pos++ ;
38.                                         str += pos ;
39. //                                        str-- ;
40.                                         *temp++ = f ;
41.                                 }
42.                                 else {
43.                                         f = *(--temp) ;
44.                                         temp-- ;
45.                                         *temp -= f ;
46.                                         temp++ ;
47.                                         *temp = 0.0 ;
48.                                         str++ ;
49.                                 }
50.                                 break ;
52.                         case '*' :
53.                                 f = *(--temp) ;
54.                                 temp-- ;
55.                                 *temp *= f ;
56.                                 temp++ ;
57.                                 *temp = 0.0 ;
58.                                 str++ ;
59.                                 break ;
61.                         case '/' :
62.                                 f = *(--temp) ;
63.                                 temp-- ;
64.                                 //如果分母是0
65.                                 if ((f > -(1e-6)) && (f < 1e-6))
66.                                         return -1 ;
67.                                 *temp /= f ;
68.                                 temp++ ;
69.                                 *temp = 0.0 ;
70.                                 str++ ;
71.                                 break ;
73.                         default :
75.                                 if ((*str >= '0') && (*str <= '9')) {
76.                                         f = atof(str) ;
77.                                         pos = Offpos(str) ;
78.                                         str += pos ;
79.                                         *temp++ = f ;
80. //                                        str-- ;
81.                                 }
82.                                 break ;
83.                 }
84.                 str++ ;
85.         }
87.         return *(--temp) ;
89. }

       主函数代码

1. int main(int argc, char* argv[])
2. {
3.         char datas[1024] = { 0 } ;
4.         char temp[] = "@-(20+-23*4)/(-1-20/2)@" ;
5.         float f = 0.0 ;
7.         Prase(datas, temp) ;
8.         f = Calculate(datas) ;
9.         return 0;
10. }

      程序写得有点乱，经过我简单的测试，目前还没有发现什么问题，如果大家有什么好的建议都可以告诉我o(∩_∩)o...哈哈，还有个问题，就是我把分母是0的时候整个表达式返回值改成了-1.0。
      对应精度的问题会引发比较严重的错误，比如说(0.9-0.8-0.1)*100000000000结果不是我们想希望的。
      参考文章
      http://www.cnblogs.com/ZHOULONG/archive/2008/04/04/1137833.html
      http://www.cnblogs.com/flyingbread/archive/2007/02/03/638932.html