好吧。代码确实是有优雅和不优雅的差别的。

cokeboL

回复 8# captivated


    他叔叔这是忙神马去了啊

captivated

回复 11# cokeboL


        学习怎么全方位地控制 CPU 中... 主要是多核 x86 和 ARM~

cokeboL

回复 12# captivated


  流弊                 

cobras

1. /* EXPRESSION CACULATOR */
   
2. 
   
3. #include <ctype.h>
   
4. #include <float.h>
   
5. #include <math.h>
   
6. #include <string.h>
   
7. #include <stdio.h>
   
8. #include <stdlib.h>
   
9. 
   
10. int nstr_trim(const char *s, int off, int lmt)
    
11. {
    
12.         int i;
    
13. 
    
14.         for (i = off; i < lmt; ++i) {
    
15.                 if (!isspace(s[i])) {
    
16.                         break;
    
17.                 }
    
18.         }
    
19.         return i;
    
20. }
    
21. 
    
22. int nstr_cmp(const char *s, int off, int lmt, const char *tar)
    
23. {
    
24.         return strncmp(s + off, tar, strlen(tar));
    
25. }
    
26. 
    
27. int get_oprand(const char *s, int *io_off, int lmt, int *o_offset, int *o_limit, double *o_value)
    
28. {
    
29.         int off, limit;
    
30.         char *endptr;
    
31.         double value;
    
32. 
    
33.         off = *io_off;
    
34.         off = nstr_trim(s, off, lmt);
    
35.         value = strtod(s + off, &endptr);
    
36.         if (value < -DBL_EPSILON || value > DBL_EPSILON) {
    
37.                 if (value > -HUGE_VAL && value < HUGE_VAL) {
    
38.                         limit = endptr - s;
    
39.                         if (o_offset != NULL) {
    
40.                                 *o_offset = off;
    
41.                         }
    
42.                         if (o_limit != NULL) {
    
43.                                 *o_limit = limit;
    
44.                         }
    
45.                         if (o_value != NULL) {
    
46.                                 *o_value = value;
    
47.                         }
    
48.                         off = limit;
    
49.                         *io_off = off;
    
50.                         return 0;
    
51.                 }
    
52.         }
    
53.         return -1;
    
54. }
    
55. 
    
56. int get_operator(const char *s, int *io_off, int lmt, int *o_type)
    
57. {
    
58.         int off;
    
59. 
    
60.         off = *io_off;
    
61.         off = nstr_trim(s, off, lmt);
    
62.         if (nstr_cmp(s, off, lmt, "+") == 0) {
    
63.                 *o_type = 0;
    
64.                 ++off;
    
65.                 *io_off = off;
    
66.                 return 0;
    
67.         }else if (nstr_cmp(s, off, lmt, "-") == 0) {
    
68.                 *o_type = 1;
    
69.                 ++off;
    
70.                 *io_off = off;
    
71.                 return 0;
    
72.         }else if (nstr_cmp(s, off, lmt, "*") == 0) {
    
73.                 *o_type = 2;
    
74.                 ++off;
    
75.                 *io_off = off;
    
76.                 return 0;
    
77.         }else if (nstr_cmp(s, off, lmt, "/") == 0) {
    
78.                 *o_type = 3;
    
79.                 ++off;
    
80.                 *io_off = off;
    
81.                 return 0;
    
82.         }
    
83.         return -1;
    
84. }
    
85. 
    
86. int get_operator_prefix(const char *s, int *io_off, int lmt, int *o_type)
    
87. {
    
88.         int off;
    
89. 
    
90.         off = *io_off;
    
91.         off = nstr_trim(s, off, lmt);
    
92.         if (nstr_cmp(s, off, lmt, "+") == 0) {
    
93.                 *o_type = 0;
    
94.                 ++off;
    
95.                 *io_off = off;
    
96.                 return 0;
    
97.         }else if (nstr_cmp(s, off, lmt, "-") == 0) {
    
98.                 *o_type = 1;
    
99.                 ++off;
    
100.                 *io_off = off;
     
101.                 return 0;
     
102.         }else if (nstr_cmp(s, off, lmt, "(") == 0) {
     
103.                 *o_type = 4;
     
104.                 ++off;
     
105.                 *io_off = off;
     
106.                 return 0;
     
107.         }
     
108.         return -1;
     
109. }
     
110. 
     
111. int get_operator_postfix(const char *s, int *io_off, int lmt, int *o_type)
     
112. {
     
113.         int off;
     
114.        
     
115.         off = *io_off;
     
116.         off = nstr_trim(s, off, lmt);
     
117.         if (nstr_cmp(s, off, lmt, ")") == 0) {
     
118.                 *o_type = 5;
     
119.                 ++off;
     
120.                 *io_off = off;
     
121.                 return 0;
     
122.         }
     
123.         return -1;
     
124. }
     
125. 
     
126. int cac_exp(int op, double opd1, double opd2, double *o_value)
     
127. {
     
128.         switch (op) {
     
129.         case 0:
     
130.                 *o_value = opd1 + opd2;
     
131.                 return 0;
     
132.         case 1:
     
133.                 *o_value = opd1 - opd2;
     
134.                 return 0;
     
135.         case 2:
     
136.                 *o_value = opd1 * opd2;
     
137.                 return 0;
     
138.         case 3:
     
139.                 *o_value = opd1 / opd2;
     
140.                 return 0;
     
141.         default:
     
142.                 return -1;
     
143.         }
     
144. }
     
145. 
     
146. int try_operator(const char *s, int off, int lmt, int *o_type)
     
147. {
     
148.         return get_operator(s, &off, lmt, o_type);
     
149. }
     
150. 
     
151. int compare_op(int op1, int op2)
     
152. {
     
153.         op1 >>= 1;
     
154.         op2 >>= 1;
     
155.         if (op1 < op2) {
     
156.                 return -1;
     
157.         }else if (op1 > op2) {
     
158.                 return 1;
     
159.         }
     
160.         return 0;
     
161. }
     
162. 
     
163. /*
     
164. * load_expression returns:
     
165. *
     
166. * 0  ok, o_value store expression's value
     
167. * 1  oh no, lower priviledge
     
168. * -1 error, gramer error
     
169. */
     
170. 
     
171. int load_expression(const char *s, int *io_off, int lmt, int op, double *io_opd)
     
172. {
     
173.         int off;
     
174.         int type, op2;
     
175.         double value;
     
176.         int load_operand(const char *s, int *io_off, int lmt, double *o_value);
     
177.        
     
178. 
     
179.         off = *io_off;
     
180.         if (get_operator(s, &off, lmt, &type) == 0) {
     
181.                 if (load_operand(s, &off, lmt, &value) == 0) {
     
182.                         if (try_operator(s, off, lmt, &op2) == 0) {
     
183.                                 if (compare_op(op2, type) == 1) {
     
184.                                         if (load_expression(s, &off, lmt, type, &value) == 0) {
     
185.                                                 cac_exp(type, *io_opd, value, io_opd);
     
186.                                                 if (load_expression(s, &off, lmt, op, io_opd) == 0) {
     
187.                                                         *io_off = off;
     
188.                                                         return 0;
     
189.                                                 }
     
190.                                         }
     
191.                                 }else {
     
192.                                         cac_exp(type, *io_opd, value, io_opd);
     
193.                                         if (load_expression(s, &off, lmt, op, io_opd) == 0) {
     
194.                                                 *io_off = off;
     
195.                                                 return 0;
     
196.                                         }
     
197.                                 }
     
198.                         }else {
     
199.                                 cac_exp(type, *io_opd, value, io_opd);
     
200.                                 *io_off = off;
     
201.                                 return 0;
     
202.                         }
     
203.                 }
     
204.         }else {
     
205.                 *io_off = off;
     
206.                 return 0;
     
207.         }
     
208.         return -1;
     
209. }
     
210. 
     
211. int load_operand(const char *s, int *io_off, int lmt, double *o_value)
     
212. {
     
213.         int off;
     
214.         int offset, limit;
     
215.         int type;
     
216.         double value;
     
217. 
     
218.         off = *io_off;
     
219.         if (get_operator_prefix(s, &off, lmt, &type) == 0) {
     
220.                 switch (type) {
     
221.                 case 0:
     
222.                         if (load_operand(s, &off, lmt, &value) == 0) {
     
223.                                 *o_value = value;
     
224.                                 *io_off = off;
     
225.                                 return 0;
     
226.                         }
     
227.                         break;
     
228.                 case 1:
     
229.                         if (load_operand(s, &off, lmt, &value) == 0) {
     
230.                                 *o_value = -value;
     
231.                                 *io_off = off;
     
232.                                 return 0;
     
233.                         }
     
234.                         break;
     
235.                 case 4:
     
236.                         if (load_operand(s, &off, lmt, &value) == 0) {
     
237.                                 if (load_expression(s, &off, lmt, -1, &value) == 0) {
     
238.                                         if (get_operator_postfix(s, &off, lmt, &type) == 0) {
     
239.                                                 if (type == 5) {
     
240.                                                         *o_value = value;
     
241.                                                         *io_off = off;
     
242.                                                         return 0;
     
243.                                                 }
     
244.                                         }
     
245.                                 }
     
246.                         }
     
247.                         break;
     
248.                 default: /* ERROR: invalid operator */
     
249.                         break;
     
250.                 }
     
251.         }else if (get_oprand(s, &off, lmt, &offset, &limit, &value) == 0) {
     
252.                 *o_value = value;
     
253.                 *io_off = off;
     
254.                 return 0;
     
255.         }
     
256.         return -1;
     
257. }
     
258. 
     
259. int caculator(const char *s, double *o_value)
     
260. {
     
261.         int off, lmt;
     
262.         int type;
     
263.         double value;
     
264. 
     
265.         off = 0;
     
266.         lmt = strlen(s);
     
267.         type = -1;
     
268.         if (load_operand(s, &off, lmt, &value) == 0) {
     
269.                 if (load_expression(s, &off, lmt, type, &value) == 0) {
     
270.                         *o_value = value;
     
271.                         return 0;
     
272.                 }
     
273.         }
     
274.         return -1;
     
275. }
     
276. 
     
277. int main(void)
     
278. {
     
279.         char exp_buf[256];
     
280.         double value;
     
281. 
     
282.         puts("I am an expression caculator.");
     
283.         while (puts("Please input an expression: Ctrl-Z to exit")
     
284.                 , fgets(exp_buf, sizeof(exp_buf), stdin) != NULL) {
     
285.                 if (caculator(exp_buf, &value) == 0) {
     
286.                         printf("= %g\n", value);
     
287.                 }else {
     
288.                         puts("Oh, It's not a valid expression, Input again.");
     
289.                 }
     
290.         }
     
291.         return 0;
     
292. }
     

复制代码

folklore

回复 12# captivated


    怪熟熟好。。。。


PS： 学这个米用的， 用到时再学不迟， 这世上CPU何其多。。。。
如果以前没学过， 先学一个倒是有必要。

seufy88

captivated,好久不见，你推荐的修养一书，我一直在翻，好几遍了。