写了一个计算四则混合运算的小程序，大家来评审一下 ^_^

starwing83

我觉得你应该先把四则运算的BNF搞清楚，然后写递归向下就很简单了，比如这样：

simpleexpr ::= number | '(' expr ')'
expr ::= ['-'] simpleexpr { binop expr }

这样总共就四个函数了：read_number, simpleexpr, binop和expr，结构会很清晰。

另外最好定义一下比较清晰的函数签名。

以上是参考Lua脚本语言的parser部分提出的。

starwing83

这个是从Lua源代码里面单独抽出来的（思路是Lua的，代码是自己写的），只有你的一半不到，你可以看看（我没有处理空格）：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <setjmp.h>
   
4. #include <math.h>
   
5. 
   
6. typedef enum BinOpr {
   
7.     OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_MOD, OP_POW, OP_NON
   
8. } BinOpr;
   
9. 
   
10. static struct { int left, right; } binop_prio[] = {
    
11.     {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, {10,9},
    
12. };
    
13. 
    
14. #define UNARY_PRIO 8
    
15. 
    
16. static BinOpr get_binop(const char **s) {
    
17.     switch (**s) {
    
18.     case '+': ++*s; return OP_ADD;
    
19.     case '-': ++*s; return OP_SUB;
    
20.     case '*': ++*s; return OP_MUL;
    
21.     case '/': ++*s; return OP_DIV;
    
22.     case '%': ++*s; return OP_MOD;
    
23.     case '^': ++*s; return OP_POW;
    
24.     default: return OP_NON;
    
25.     }
    
26. }
    
27. 
    
28. static double doexpr(int op, double a, double b) {
    
29.     switch (op) {
    
30.     case OP_ADD: return a+b;
    
31.     case OP_SUB: return a-b;
    
32.     case OP_MUL: return a*b;
    
33.     case OP_DIV: return a/b;
    
34.     case OP_MOD: return a-floor(a/b)*b;
    
35.     case OP_POW: return pow(a, b);
    
36.     default: return 0;
    
37.     }
    
38. }
    
39. 
    
40. typedef struct ExprContext {
    
41.     jmp_buf jbuf;
    
42.     const char *errmsg, *s;
    
43.     BinOpr op;
    
44. } Expr;
    
45. 
    
46. static double error(Expr *e, const char *msg) {
    
47.     e->errmsg = msg;
    
48.     longjmp(e->jbuf, 1);
    
49. }
    
50. 
    
51. static double expr(Expr *e, int limit) {
    
52.     double n;
    
53.     BinOpr op;
    
54.     if (*e->s == '-') {
    
55.         ++e->s;
    
56.         n = -expr(e, UNARY_PRIO);
    
57.     }
    
58.     else if (*e->s == '(') {
    
59.         ++e->s;
    
60.         n = expr(e, 0);
    
61.         if (*e->s++ != ')') error(e, "')' expected");
    
62.     }
    
63.     else {
    
64.         const char *s = e->s;
    
65.         n = strtod(s, (char**)&e->s);
    
66.         if (e->s == s) error(e, "'number' expected");
    
67.     }
    
68.     op = get_binop(&e->s);
    
69.     while (op != OP_NON && binop_prio[op].left > limit) {
    
70.         n = doexpr(op, n, expr(e, binop_prio[op].right));
    
71.         op = e->op;
    
72.     }
    
73.     e->op = op;
    
74.     return n;
    
75. }
    
76. 
    
77. double calc(const char *s, const char **perr) {
    
78.     Expr e;
    
79.     e.s = s;
    
80.     e.errmsg = NULL;
    
81.     if (setjmp(e.jbuf) == 0) {
    
82.         double n = expr(&e, 0);
    
83.         if (*e.s != '\n' && *e.s != '\0' && *e.s != '=')
    
84.             error(&e, "traling chars detected");
    
85.         return n;
    
86.     }
    
87.     if (perr) *perr = e.errmsg;
    
88.     return 0;
    
89. }
    
90. 
    
91. int main(void) {
    
92.     char buff[BUFSIZ];
    
93.     while (printf("> "), fgets(buff, BUFSIZ, stdin) != NULL) {
    
94.         const char *errmsg = NULL;
    
95.         double n = calc(buff, &errmsg);
    
96.         if (errmsg) printf("ERROR: %s\n", errmsg);
    
97.         else printf("%g\n", n);
    
98.     }
    
99.     return 0;
    
100. }
     

复制代码

linux_c_py_php

后续遍历,  这是<竞赛经典入门>里建表达式树的东西.

sonicling

回复 6# pmerofc


    这是简单语言。实用一些的想避免大函数都不行，几十个运算符，光switch case都要写几十上百行。

starwing83

回复 7# sonicling


    你见过几十个运算符的语言么？C？那也才三十多个，没有上百行吧？

而且，其实很多switch-case是可以被归结成一个数据表的啊。

说到最后，其实还是设计上的问题。我上面的帖子最开始其实是两个函数simpleexpr和expr，是觉得simpleexpr只用了一次而已，就人肉内联到expr了而已。

Lua语言，这是真实语言了吧，它的lparser里面就根本没有大函数的。