字符串表达式 计算表达式

jz1043

calc.exe   v1*v1+v2*v3   10  20  30  40
           calc.exe ： 程序名
v1*v1+v2*v3 ： 字符串表达式
10  20  30  40 ： 4个参数

最重要的是把字符串表达式v1*v1+v2*v3 转化成计算表达式，现在没有什么可行的思路， 请各位给点指导，谢谢。

ilwmin

没太明白

yulihua49

calc.exe   v1*v1+v2*v3   10  20  30  40
           calc.exe ： 程序名
v1*v1+v2*v3 ： 字符串表达式 ...
jz1043 发表于 2011-08-09 17:08

哈哈，我有类似的玩意儿。
不过，变量是项号，可以理解为数组下标。

1. 
   
2. 2. 字典编写规则
   
3. 
   
4.         ① 基本运算符
   
5. 
   
6.             ()
   
7.             算术运算符:         +, -, *, /, %  ( 优先级 )
   
8.             逻缉运算符:         =, <=, >=, <>, !=,
   
9.                                 &,|
   
10.                                 :?
    
11. 
    
12.         ② 基本格式
    
13. 
    
14.             每行由两部分组成,前半部份为表达式, 由分号隔开的后半部份
    
15.             为格式说明, '#'后可跟注释,如需打印#,可用\#.
    
16. 
    
17. 
    
18.             1. 算术表达式
    
19. 
    
20.                算术表达式可由三种最基本的表达式组成
    
21. 
    
22.                (1)    a1,a2,a3,a4,a5, n 尾标
    
23.                       ┃          ┃  ┃
    
24.                       ┗━━┳━━━┛  ┗━━━━━━━━┓
    
25.                            ┃                        ┃
    
26.                            ┃                        ┃
    
27.                            ┃                        ┃
    
28.                          索引标记                     项号
    
29. 
    
30.                索引标记: 由字母或数字构成, 若含有 + - * / % , \
    
31.                                  应前置 \ 引导.
    
32.                        项    号: 由数字构成.
    
33.                        尾    标: 由一个字母构成 a - z, A - Z.
    
34.                (2)    nL
    
35.                     字典用存储变量. 详见存储规则
    
36.                (3) 浮点表达式, 代表立即数. 例: 0.5, -5e10.
    
37.     2. 条件表达式
    
38. 
    
39.             单行条件表达式：
    
40.                若e1, e2和e3是三个算术表达式, 则在条件表达式
    
41.                        e1?e2:e3
    
42.                e1的格式：变量或数值 操作符 变量或数值 逻辑操作符 ...
    
43.                中, 首先计算e1的值, 若非零(真), 则计算e2的值, 并且此值就是该表达
    
44.                式的值; 否则, 计算e3的值, 并且此值就是该表达式的值. e2和e3仅有一
    
45.                个被求值.  e2 和 e3 含有格式说明.
    
46. 
    
47.             多行条件表达式：
    
48.                        条件表达式？
    
49.                         条件为真的语句
    
50.                        ：
    
51.                         条件为假的语句
    
52.                        $
    
53.                        条件表达式？
    
54.                         条件为真的语句
    
55.                        ：第二个条件表达式？       # else if，可以有多个
    
56.                         第二个条件为真的语句
    
57.                        ：                         # 可以没有
    
58.                         条件为假的语句
    
59.                        $
    
60. 
    
61.            条件表达式可以嵌套使用。
    
62. 
    
63.             3. 输出格式规则
    
64. 
    
65.                若表达式后跟有分号, 则表明本行字典值要输出. 格式为 ;m.n
    
66.                其中: m 为保留小数位数
    
67.                      无n时m:为小数点左移位数.
    
68.                   n 为舍入规则
    
69. n: 0-- 遇0输出0 四舍五入.
    
70.    以下遇0输出空
    
71.    1-- 向-舍入.
    
72.    2-- 向+舍入.
    
73.    3-- 向0舍入.
    
74.    4-- 只入.
    
75.    5-- 四舍五入.
    
76.    无- 小数点左移m位,四舍五入.  为加权四舍五入.
    
77.                 例:
    
78.                      3450.495;2.5
    
79.                      3450.50
    
80. 
    
81.                      3450.495;2
    
82.                      34.50
    
83. 
    
84.                      3450.50;2
    
85.                      34.51
    
86. 
    
87.                     ;g float format
    
88.                     ;y: 年
    
89.                     ;m: 月
    
90.                     ;d: 日
    
91.                     ;w: 星期
    
92.                     ;Y: 年月日
    
93.                     ;j: 季度
    
94.                     ;l: 字符串打印小写
    
95.                     ;u: 字符串打印大写
    
96.                     ;n: 不打印
    
97. 
    
98.                     ;+m.n  输出需要+-号
    
99.                     ;0m    输出m位宽, 补前0
    
100.                     ; m    输出m位宽, 补空格
     
101.              基本格式之后跟其他字符将被打印出来, 行尾的&表示不换行.
     
102. 
     
103.             4. 字典日期
     
104. 
     
105.                     D:  日期
     
106.                     0D:  数据库日期 本月  几日
     
107.                     1D:  记录的日
     
108.                     2D:  当日的日 (程序日期)
     
109.                     3D:  当年的天数
     
110.                     4D:  程序指定的月份
     
111.                     6D:  内部日
     
112.                     7D:  季度天数
     
113. 
     
114.                 日期表达式
     
115. 
     
116.                     .               当日
     
117.                     \+1          明天
     
118.                     \-1           昨天
     
119.                     .\-1.,2D;   昨日日期
     
120.                     .L,2D;      月底日
     
121.                     . .,4D;     当日月份
     
122. 
     
123.         ③ 存储规则
     
124. 
     
125.             字典具有变量存储功能. 要将某字典行的值存储, 可写成 nL=表达式.
     
126.             (其中, n为正整数),  其中, nL即为变量,其中 0<= n <=9,若超过此
     
127.             值,则须用 LABN=n  加以说明. 此说明应单独占一行.
     
128. 
     
129. 
     
130.         ④ 缺省规则
     
131. 
     
132.             编写字典时, 索引标记部分的值均可省略, 若某个值缺省, 则其值为
     
133.             前一次查找记录所使用的索引值, 依此类推.
     
134. 
     
135. 
     
136.         ⑤ 几个完整字典行
     
137. 
     
138.             LABN=m
     
139.             nL=A+B/C+1000.;      #  (即存储又输出)
     
140.             pL=E+nL              #         (存储不输出)
     
141.             A?B;:C-D;2.0          #         (若A为真, 则输出B, 否则输出C,
     
142.                                  #          输出格式为保留两位小数, 全舍)
     
143. 
     
144.             注: 上例中 A,B,C,D,E 均为算术表达式. m,n,p为正整数.
     
145. 
     
146.         ⑥ 字典特别说明
     
147. 
     
148. 
     
149.             表达式  项  操作符
     
150.             表达式  [; 格式]
     
151.                      ; 输出
     
152. 
     
153.                日期,单位,表名,标记,项号
     
154. 
     
155.               例如:
     
156.               .,1000,kyl,101,1..14;
     
157.                                ↑
     
158.                              1 至 14 项输出
     
159. 
     
160.               .,1000,byb2,101,1..61=.,1000,yb2,101,1&&-,,qyb2,,1&&;
     
161.                                ↑                  ↑          ↑
     
162.                        byb2的  1 至 61 项     =    yb2的1 至 61 项 -  qyb2的1 至 61 项
     
163. 
     
164.                              ;ABC 输出 ABC
     
165.                              9++14;    9+10+11+12+13+14  之和输出
     
166. 
     
167.               赋值表达式
     
168.                .,1000,kyl,102,19=.,1000,kyl,102,18/17  第 19 项为第 18 项 / 第 17 项
     
169. 
     
170. 
     

复制代码

Moon_Bird

首先 程序中 应将 字符串表达式作为第一个参数传入进行分离 ，然后使其中的变量=其后的参数吧

cobras

变量替换比较简单。复杂的是运算符如果有优先级，则需要使用栈来实现。没有优先级则简单。

yulihua49

变量替换比较简单。复杂的是运算符如果有优先级，则需要使用栈来实现。没有优先级则简单。
cobras 发表于 2011-08-09 17:39

    逆波兰表达式。
递归栈。

项号替换是回调函数。你自己定义如何取得数据。

yulihua49

变量替换比较简单。复杂的是运算符如果有优先级，则需要使用栈来实现。没有优先级则简单。
cobras 发表于 2011-08-09 17:39

基本的表达式计算，不包括条件语句的处理。

1. cat calcu.c
   
2. /* @(#) calc.c 1.4 91/04/19 */
   
3. #include <stdio.h>
   
4. #include <ctype.h>
   
5. #include <regex.h>
   
6. #include <sdbc.h>
   
7. 
   
8. #include "calc.h"
   
9. 
   
10. struct args {
    
11.         double (*getdata)(int,int,char *[CALCID]);
    
12.         int argc;
    
13.         char *argv[CALCID];
    
14.         char argbuf[130];
    
15.         char *cp;
    
16. };
    
17. 
    
18. /*double getdata(int,char,int,char[CALCID][CALCIDLEN]);*/
    
19. static char * setarg(struct args *);
    
20. static double cal(double,int,struct args *),F0=0.;
    
21. 
    
22. static char Moper_src[]="^[     ]*(-{0,1}[0-9]{1,5})[+][+](-{0,1}[0-9]{1,5})";
    
23. static regex_t Moper;
    
24. static int regflg=0;
    
25. #define MAXREG 5
    
26. static regmatch_t pmatch[MAXREG];
    
27. /*
    
28. static char Moper[] = {
    
29. 040,031,03,040,011,027,055,00,01,033,04,020,
    
30. 060,071,01,05,030,02,053,030,02,053,074,00,
    
31. 027,055,00,01,033,04,020,060,071,01,05,014,
    
32. 00,00,064,
    
33. 0};
    
34. */
    
35. 
    
36. static char *__loc1;
    
37. //主要函数，getdata是取数回调函数。
    
38. double calculator(str,getdata)
    
39. char *str;
    
40. double (*getdata)(int,int,char *[CALCID]);
    
41. {
    
42. struct args arg;
    
43.         if(!str||*str=='#'||*str==';') return 0.;
    
44.         if(!regflg) {
    
45.         int ret;
    
46.         char errbuf[200];
    
47.                 ret=regcomp(&Moper,Moper_src,REG_EXTENDED);
    
48.                 if(ret) {
    
49.                         regerror(ret,&Moper,errbuf,sizeof(errbuf));
    
50.                         fprintf(stderr,"%s\n",errbuf);
    
51.                         return 0;
    
52.                 }
    
53.                 regflg=1;
    
54.         }
    
55.         arg.getdata=getdata;
    
56.         arg.cp=str;
    
57.         return(cal(0.,ADD,&arg));
    
58. }
    
59. //递归计算。
    
60. static double cal(x,op,arg)
    
61. double x;
    
62. int op;
    
63. register struct args *arg;
    
64. {
    
65. char *rp;
    
66. double tmp;
    
67. union {
    
68.         int n;
    
69.         long l;
    
70.         } m;
    
71. 
    
72.         if(!*arg->cp) return(calc(x,op,0.));
    
73.         tmp=F0,m.l=0;
    
74.         do {
    
75. 
    
76.                 if(*arg->cp=='('/*)*/) {
    
77.                         arg->cp++;
    
78.                         tmp=cal(0.,ADD,arg);
    
79.                         rp=arg->cp;
    
80.                         goto oper;
    
81.                 }
    
82.                 setarg(arg);
    
83.                 if(*arg->cp<=' ') {
    
84.                         arg->cp++;
    
85.                         if(!*arg->cp) x=calc(x,op,tmp);
    
86.                         continue;
    
87.                 }
    
88.                 m.l=0;
    
89.                 if(tolower(*arg->cp)=='c') {
    
90.                         tmp=strtod(arg->cp+1,&rp);
    
91.                         if(isdigit(*rp)) rp++;
    
92.                         if(rp==arg->cp+1) {
    
93.                                 arg->cp=++rp;
    
94.                                 if(!*rp)  {
    
95.                                         x=calc(x,op,tmp);
    
96.                                         break;
    
97.                                 }
    
98.                                 continue;
    
99.                         }
    
100.                 }
     
101.                 else {
     
102.                 char right[7];
     
103.                 char *p;
     
104.                         tmp=strtod(arg->cp,&rp);
     
105.                         if(rp!=arg->cp) {
     
106.                                 if(isdigit(*rp)) rp++;
     
107.                                 if(!arg->getdata) goto oper;
     
108.                                 for(p=arg->cp;p<rp;p++) {
     
109.                                         if(*p=='.' || *p=='E' || *p=='e') {
     
110.                                                 goto oper;
     
111.                                         }
     
112.                                 }
     
113.                         }
     
114.                         if(!regexec(&Moper,arg->cp,MAXREG,pmatch,0)) {
     
115.                         int i;
     
116. 
     
117.                                 p=arg->cp+pmatch[0].rm_eo;
     
118.                                 __loc1=arg->cp+pmatch[1].rm_so;// 线程不安全。
     
119.                                 i=pmatch[2].rm_eo-pmatch[2].rm_so;
     
120.                                 strncpy(right,arg->cp+pmatch[2].rm_so,i);
     
121.                                 right[i]=0;
     
122. 
     
123. /* XXXXX   1++80  
     
124. fprintf(stderr,"calc:left=%s, right=%s\n",lft,right);
     
125. */
     
126.                            tmp=F0;
     
127.                            if(isalpha(*p)) *arg->argv[0]=*p++;
     
128.                            else *arg->argv[0]=0;
     
129.                             m.l=atoi(right);
     
130.                             for(i=atoi(__loc1);i<=m.n;i++) {
     
131.                                if(arg->getdata)
     
132.                                   tmp+=(*arg->getdata)(i,arg->argc,arg->argv);
     
133.                                else tmp+=(double)i;
     
134.                             }
     
135.                             rp=p;
     
136.                         }
     
137.                         else {
     
138.                            if(*arg->cp) m.l=strtol(arg->cp,&rp,0);
     
139.                            if(isalpha(*rp)) *arg->argv[0]=*rp++;
     
140.                            else *arg->argv[0]=0;
     
141.                            if(arg->getdata) {
     
142.                               tmp=(*arg->getdata)(m.n,arg->argc,arg->argv);
     
143.                            }
     
144.                            else tmp=(double)m.l;
     
145.                         }
     
146.                 }
     
147. oper:
     
148.                 if(!*rp) {
     
149.                         x=calc(x,op,tmp);
     
150.                         arg->cp=rp;
     
151.                         break;
     
152.                 }
     
153.                 while(isspace(*rp)) rp++;
     
154.                 switch(*rp) {
     
155.                 case '+': m.n=ADD;
     
156.                           rp++;
     
157.                           break;
     
158.                 case '-': m.n=SUBT;
     
159.                           rp++;
     
160.                           break;
     
161.                 case '*': m.n=MUL;
     
162.                           rp++;
     
163.                           break;
     
164.                 case '/': m.n=DIV;
     
165.                           rp++;
     
166.                           break;
     
167.                 case '%': m.n=MOD;
     
168.                           rp++;
     
169.                           break;
     
170. /*
     
171.                 case ')':
     
172. printf("op=%d,x=%f m.n=%d tmp=%f rp=%s\n",op,x,m.n,tmp,rp);
     
173.                           if(*rp) rp++;
     
174.                           if(x==0. && op==0) {
     
175.                                 return tmp;
     
176.                           }
     
177.                           m.n=-1;
     
178.                           break;
     
179. */
     
180.                 case '\n':
     
181.                 case '\r':
     
182.                 case ';':
     
183.                 case '#': *rp=0;
     
184.                 default: m.n=-1;
     
185.                           if(*rp) rp++;
     
186.                           break;
     
187.                 }
     
188.                 arg->cp=rp;
     
189. 
     
190.                 if(m.n==-1) {
     
191.                         x=calc(x,op,tmp);
     
192.                         break;
     
193.                 }
     
194.                 else if((m.n>>2) > (op>>2)){
     
195.                         tmp=cal(tmp,m.n,arg);
     
196.                         rp=arg->cp;
     
197. 
     
198.                         goto oper;
     
199.                 }
     
200.                 x=calc(x,op,tmp);
     
201.                 if((m.n>>2) == (op>>2)) {
     
202.                         op=m.n;
     
203.                 }
     
204.                 else  {
     
205.                         arg->cp--;
     
206.                         break;
     
207.                 }
     
208. 
     
209.         } while(*arg->cp);
     
210.         return(x);
     
211. }
     
212. 
     
213. let(str,x,putdata)
     
214. char *str;
     
215. double x;
     
216. int (*putdata)(int,int,char *[CALCID],double);
     
217. {
     
218. struct args arg;
     
219. int n=0;
     
220. char *p;
     
221.         arg.cp=str;
     
222.         setarg(&arg);
     
223.         n=strtol(arg.cp,&p,0);
     
224.         if(p==arg.cp) return(-1);
     
225.         if(p&&isalpha(*p)) *arg.argbuf=*p;
     
226.         return((*putdata)(n,arg.argc,arg.argv,x));
     
227. }
     
228. static char * setarg(arg)
     
229. register struct args *arg;
     
230. {
     
231. int n;
     
232. register char *rp;
     
233. char *p;
     
234.         arg->argc=0;
     
235.         *(arg->argv[0]=arg->argbuf)=0;
     
236.         for(n=1;n<CALCID;n++) {
     
237.                 *(p=arg->argv[n]=arg->argv[n-1]+strlen(arg->argv[n-1])+1)=0;
     
238. again:
     
239.                 if((p-arg->argbuf) >= sizeof(arg->argbuf)-1)
     
240.                         break;
     
241.                 rp=stptok(arg->cp,p,
     
242.                         sizeof(arg->argbuf)-(p-arg->argbuf),
     
243.                         ",+*-/%()#;");
     
244.                 if(*rp && rp[-1]=='\\') {
     
245.                         p=arg->argv[n]+strlen(arg->argv[n])-1;/* del \\ */
     
246.                         *p++=*rp++;
     
247.                         *p=0;
     
248.                         arg->cp=rp;
     
249.                         goto again;
     
250.                 }
     
251.                 if(*rp!=',') break;
     
252.                 arg->cp=rp+1,arg->argc=n;
     
253.         }
     
254.         return(arg->cp);
     
255. }
     
256. int strlet(label,str,putdata)
     
257. char *label;
     
258. char *str;
     
259. int (*putdata)(int,int,char *[CALCID],char *str);
     
260. {
     
261. struct args arg;
     
262. int n=0;
     
263. char *p;
     
264.         arg.cp=label;
     
265.         setarg(&arg);
     
266.         n=strtol(arg.cp,&p,0);
     
267.         if(p==arg.cp) return(-1);
     
268.         if(p&&isalpha(*p)) *arg.argbuf=*p;
     
269.         return((*putdata)(n,arg.argc,arg.argv,str));
     
270. }
     

复制代码