中缀式四则运算计算器 －－ C语言习作

kikiwarm

又是一个小程序，学过编程的大概都写过类似程序了，反正写了就放上来，这里还是有一些编程初学者的，和我一样的菜鸟请多交流，高手有空就指点一两句吧，谢谢！


用到了两个栈，一个栈的元素类型是 double，另一个栈的元素类型是 char，用 union 把它们结合在一起

1. 
   
2. union Era
   
3. {
   
4.   double nd;    // op.era.nd
   
5.   char tor;     // op.era.tor
   
6. };
   

复制代码

这样就可以用同一套pop()和push()函数来处理两个栈了，否则就要写两套大同小异的pop()和push()。

pointer

如果很小的话, 就别用附件了, 直接嵌在里面有好一些.

pointer

你的我下载不了?

也发一个抄自书上的:

1. 
   
2. #include<ctype.h>
   
3. #include<stdio.h>
   
4. #include<stdlib.h>
   
5. 
   
6. #define NUM 257
   
7. #define NONE 258
   
8. 
   
9. 
   
10. int lookahead;
    
11. int lineno = 1;
    
12. int tokenval=NONE;
    
13. 
    
14. double expr();
    
15. 
    
16. 
    
17. // exp -> term rest
    
18. // rest -> empty
    
19. //      -> + term rest
    
20. //      -> - term rest
    
21. // term -> factor termrest
    
22. // termrest -> * factor termrest
    
23. //          -> / factor termrest
    
24. // factor -> num
    
25. //        -> (expr)
    
26. 
    
27. void error(char *s){
    
28.   printf("syntax error:%s\n",s);
    
29.   exit(1);
    
30. }
    
31. 
    
32. int lexan()
    
33. {
    
34.   int t;
    
35.   while(1){
    
36.     t=getchar();
    
37.     if(t==' ' || t=='\t' ) ;
    
38.     else if(t=='\n')
    
39.       lineno++;
    
40.     else if(isdigit(t)){
    
41.       tokenval=t-'0';
    
42.       t=getchar();
    
43.       while(isdigit(t)){
    
44.         tokenval=tokenval*10+t-'0';
    
45.         t=getchar();
    
46.       }
    
47.       ungetc(t, stdin);
    
48.       return NUM;
    
49.     }
    
50.     else {
    
51.       tokenval=NONE;
    
52.       return t;
    
53.     }
    
54.   }
    
55. }
    
56. 
    
57. void match(int t){
    
58.   if(lookahead==t){
    
59.     lookahead=lexan();
    
60.   }
    
61.   else error("in match");
    
62. }
    
63. 
    
64. double factor(){
    
65.   double r=0;
    
66.   if(lookahead=='('){
    
67.     match('(');
    
68.     r=expr();
    
69.     match(')');
    
70.   }
    
71.   else if( lookahead==NUM){
    
72.     r=tokenval;
    
73.     match(NUM);
    
74.   }
    
75.   else error("in factor");
    
76.   return r;
    
77. }
    
78. 
    
79. double term(){
    
80.   double num=factor();
    
81.   while(1){
    
82.     if(lookahead=='*'){
    
83.       match('*');
    
84.       num*=factor();
    
85.     }
    
86.     else if( lookahead=='/'){
    
87.       match('/');
    
88.       num/=factor();
    
89.     }
    
90.     else break;      
    
91.   }
    
92.   return num;
    
93. }
    
94. 
    
95. double expr(){
    
96.   double left=term();
    
97.   while(1){
    
98.     if(lookahead=='+'){
    
99.       match('+');
    
100.       left+=term();
     
101.       
     
102.     } else if(lookahead=='-'){
     
103.       match('-');
     
104.       left-=term();
     
105.     }
     
106.     else break;
     
107.   }
     
108.   return left;
     
109. }
     
110. 
     
111. 
     
112. int main(int argc, char **argv)
     
113. {
     
114.   lookahead=lexan();
     
115.   while(!feof(stdin)){
     
116.     printf("\n%f\n",expr());
     
117.   }
     
118.   return 0;
     
119. }
     

复制代码

kikiwarm

2. /* infix calculator version 0.1.3 #20060428
3. * by 419Labs
4. * kikistar.com@gmail.com
5. * http://my.opera.com/419/
6. *
7. * References:
8. * 1.[K&R] The C Programming Language (second edition)
9. *                                            影印版 ISBN 7-302-02412-X/TP.1214
10. * 2.[Mark Allen Weiss] Data Structures and Algorithm Analysis in C
11.                              (second edition) 中文版 ISBN 7-111-12748-X
12. * 3.[严蔚敏 吴伟民] 数据结构（C语言版）             ISBN 7-900643-22-2
13. */
15. #include <stdio.h>
16. #include <stdlib.h>
17. #include <ctype.h>
19. #define MAXOP        100
20. #define NUMBER        '0'        // signal that a number was found
21. #define EMPTY        0
22. enum Optype { ND, TOR };        // ND for operand, TOR for operator
24. union Era
25. {
26.   double nd;        // op.era.nd
27.   char tor;        // op.era.tor
28. };
30. struct Op
31. {
32.   int max;
33.   int top;
34.   enum Optype type;
35.   union Era *era;
36. };
38. struct Op *create_stack(int max, enum Optype);
39. void push(union Era, struct Op *);
40. union Era pop(struct Op *);
41. void nullerr(void);
42. int getop(char []);
43. double operate(struct Op *opnd, struct Op *optor);
44. void print_stack(struct Op *op);
45. char top_tor(struct Op *);
47. int
48. main()
49. {
50.   int c;
51.   char s[MAXOP];
52.   union Era era;
53.   struct Op *opnd;
54.   struct Op *optor;
56.   opnd = create_stack(MAXOP, ND);
57.   optor = create_stack(MAXOP, TOR);
59.   printf(" 本程序可进行“加减乘除(+ - * /)”四则混合运算。\n");
60.   printf(" 输入 q 或按 Ctrl+D 退出程序。\n");
61.   printf(" 输入算式后按回车即可算出答案：\n\n");
63.   while ((c = getop(s)) != EOF) {
64.     switch (c) {
65.     case NUMBER:
66.       if (opnd->top > optor->top + 1) {        // 如果是逆波兰算式
67.         printf("\tparse error\n");
68.         while (getchar() != '\n')
69.           /*void*/;
70.         opnd->top = EMPTY;
71.         era.nd = 0.0;
72.       }
73.       else
74.         era.nd = atof(s);
75.       push(era, opnd);
76.       break;
77.     case '+':            // + 和 - 优先级最低，把除了 '(' 以外的全部操作符弹出后入栈
78.     case '-':
79.       if (optor->top == EMPTY) {
80.         era.tor = c;
81.         push(era, optor);
82.       }
83.       else {
84.         while (optor->top > EMPTY)
85.           if (top_tor(optor) == '(')
86.             break;
87.           else {
88.             era.nd = operate(opnd, optor);
89.             push(era, opnd);
90.           }
91.         era.tor = c;
92.         push(era, optor);
93.       }
94.       break;
95.     case '*':                      // 乘除优先级最高，把相同优先级的乘和除弹出后入栈
96.     case '/':
97.       if (optor->top == EMPTY) {
98.         era.tor = c;
99.         push(era, optor);
100.       }
101.       else {
102.         while (optor->top > EMPTY)
103.           if (((era.tor = top_tor(optor)) == '+')
104.               || (era.tor == '-')
105.               || (era.tor == '('))
106.             break;
107.           else {
108.             era.nd = operate(opnd, optor);
109.             push(era, opnd);
110.           }
111.         era.tor = c;
112.         push(era, optor);
113.       }
114.       break;
115.     case '(':                // '(' 不作运算，直接放入optor栈。
116.       era.tor = c;
117.       push(era, optor);
118.       break;
119.     case ')':                // 把 '(' 之前的全部操作符弹出，计算后把 '(' 也弹出
120.         while (optor->top > EMPTY)
121.           if (top_tor(optor) == '(')
122.             break;
123.           else {
124.             era.nd = operate(opnd, optor);
125.             push(era, opnd);
126.           }
127.         pop(optor);
128.       break;
129.     case '\n':                // 把余下的操作符全部弹出，计算后输出结果
130.       if (opnd->top == EMPTY)
131.         /*do nothing*/;
132.       else
133.         while (optor->top > EMPTY)
134.           if (top_tor(optor) == '(')
135.             pop(optor);
136.           else {
137.             era.nd = operate(opnd, optor);
138.             push(era, opnd);
139.           }
140.       era = pop(opnd);
141.       printf("\t%.8g\n", era.nd);
142.       break;
143.     case 'p':
144.       print_stack(opnd);
145.       getchar();
146.       break;
147.     case 'q':
148.       exit(0);
149.       break;
150.     default:
151.       printf("error: unknown command %s\n", s);
152.       break;
153.     }
154.   }
155.   return 0;
156. }
158. struct Op *create_stack(int max, enum Optype type)
159. {
160.   struct Op *op;
162.   op = malloc(sizeof(*op));
163.   if (op == NULL)
164.     nullerr();
166.   op->era = calloc(sizeof(union Era), max);
167.   if (op->era == NULL)
168.     nullerr();
170.   op->max = max;
171.   op->top = EMPTY;
172.   op->type = type;
174.   return op;
175. }
177. void
178. push(union Era era, struct Op *op)
179. {
180.   if (op->top >= op->max) {
181.     if (op->type == ND)
182.       printf("error: stack full, can't push %g\n", era.nd);
183.     else
184.       printf("error: stack full, can't push %c\n", era.tor);
185.   }
186.   else
187.     op->era[op->top++] = era;
188. }
190. union Era
191. pop(struct Op *op)
192. {
193.   if (op->top > EMPTY)
194.     return op->era[--op->top];
195.   else {
196.     printf("error: stack empty\n");
197.     if (op->type == ND)
198.       op->era[EMPTY].nd = 0.0;
199.     else
200.       op->era[EMPTY].tor = 0;
201.     return op->era[EMPTY];
202.   }
203. }
205. void nullerr(void)
206. {
207.   printf("not enough memory\n");
208.   exit(1);
209. }
211. int getop(char s[])        // [K&R] section 4.3
212. {
213.   int i, c;
215.   while ((s[0] = c = getchar()) == ' ' || c == '\t')
216.     /*do nothing*/;
217.   s[1] = '\0';
218.   if (!isdigit(c) && c != '.')
219.     return c;                // not a number
220.   i = 0;
221.   if (isdigit(c))        // collect integer part
222.     while (isdigit(s[++i] = c = getchar()))
223.       ;
224.   if (c == '.')                // collect fraction part
225.     while (isdigit(s[++i] = c = getchar()))
226.       /*do nothing*/;
227.   s[i] = '\0';
228.   if (c != EOF)
229.     ungetc(c, stdin);
230.   return NUMBER;
231. }
233. double operate(struct Op *opnd, struct Op *optor)
234. {
235.   union Era nd1, nd2, tor;
237.   nd2 = pop(opnd);
238.   nd1 = pop(opnd);
239.   tor = pop(optor);
241.   switch (tor.tor) {
242.   case '+':
243.     return nd1.nd + nd2.nd;
244.     break;
245.   case '-':
246.     return nd1.nd - nd2.nd;
247.     break;
248.   case '*':
249.     return nd1.nd * nd2.nd;
250.     break;
251.   case '/':
252.     return nd1.nd / nd2.nd;
253.     break;
254.   default:
255.     return 0.0;
256.     break;
257.   }
258. }
260. void print_stack(struct Op *op)
261. {
262.   int i;
263.   for (i = op->top; i > 0; i--)
264.     printf("%g\n", op->era[i].nd);
265. }
267. char top_tor(struct Op *op)
268. {
269.   return op->era[op->top-1].tor;        // after push, top plus one
270. }

复制代码

kikiwarm

多谢pointer提醒。我贴在上面了。
你那个程序怎么比我的短那么多！什么书里出来的？
我正在研究你这个程序，不知道为什么每次计算完都说syntax error:in factor

kikiwarm

那程序就是用你所说的形式语言编的吧？比我的简短很多呀！

加减运算的函数调用乘除运算的函数，乘除运算的函数调用括号函数，括号函数又反过来调用加减运算的函数－－如此形成递归！现在我只能这样大概理解，其中的细节和逻辑一时半刻搞不懂，先收藏，以后多学点递归再回头看。

soloforce

形式语言可不是这玩儿

ywchen2000

改BS的......

#include<iostream>
#include<map>
#include<string>
#include<cctype>
#include<math.h>
using namespace std;
class expr;
enum Token_value{
SQRT,SIN,COS,
NAME,NUMBER,END,
PLUS='+',MINUS='-',MUL='*',DIV='/',
PRINT=';',ASSIGN='=',LP='(',RP=')',MIN='^'
};
typedef double (*dfdp)(double);
dfdp math[]={sqrt,sin,cos};
int i;
typedef Token_value (expr::*get_token_p_p)();
get_token_p_p get_token_p;
class expr{
public:
expr(const char* str);
expr(void);
void jisuan(void);
double eval();
void print(){}

private:
int line_no;

string string_expr;
double (*dfddp)(double,double);
double number_value;
string string_value;
map<string,double> table;
Token_value curr_tok;
double my_expr(bool get);
double term(bool get);
double prim(bool get);
double min(bool get);
Token_value get_token(void);
Token_value get_token_ios(void);

double error(char *str);
};
expr::expr(void)
{
line_no=0;
i=-1;
number_value=0;
table["pi"]=3.1415;
table["e"]=2.718281;

}
expr::expr(const char* str)
{
string_expr=str;
expr();
}
double expr::error(char *str)
{
cerr<<"line:"<<line_no<<" "<<str<<endl;
return 1;
}
double expr::my_expr(bool get)
{
double left=term(get);
for(;;)
switch(curr_tok){
case PLUS:
left+=term(true);
break;
case MINUS:
left-=term(true);
break;
default:
return left;
}
}
double expr::term(bool get)
{
double left=min(get);
for(;;)
switch(curr_tok){
case MUL:
left*=min(true);
break;
case DIV:
if(double d=min(true)){
left/=d;
break;
}
return error("divide by 0");
default:
return left;
}
}
double expr::min(bool get)
{
double left=prim(get);
dfddp=pow;
for(;;)
{
switch(curr_tok){
case MIN:
left=dfddp(left,prim(true));
break;
case SQRT:
left=math[SQRT](left);
(this->*get_token_p)();
return left;
case SIN:
left=math[SIN](left);
(this->*get_token_p)();
return left;
case COS:
left=math[COS](left);
(this->*get_token_p)();
return left;
default:
return left;
}
}
}
double expr::prim(bool get)
{
if(get) (this->*get_token_p)();
switch(curr_tok){
case NUMBER:
{
double v=number_value;
(this->*get_token_p)();
return v;
}
case NAME:
{
if(strcmp(string_value.c_str(),"sqrt")==0)
{
(this->*get_token_p)();
if(curr_tok!=LP) return error("(expected");
double e=my_expr(true);
if(curr_tok!=RP) return error(")expected");
//get_token(); // delete RP;
curr_tok=SQRT;
return e;
}
else if(strcmp(string_value.c_str(),"sin")==0)
{
(this->*get_token_p)();
if(curr_tok!=LP) return error("( expected");
double e=my_expr(true);
if(curr_tok!=RP) return error(")expected");
curr_tok=SIN;
return e;
}
else if(strcmp(string_value.c_str(),"cos")==0)
{
(this->*get_token_p)();
if(curr_tok!=LP) return error("( expected");
double e=my_expr(true);
if(curr_tok!=RP) return error(")expected");
curr_tok=COS;
return e;
}
else {

double& v=table[string_value];
if((this->*get_token_p)()==ASSIGN)
{ line_no++; v=my_expr(true);}
return v;
}
}
case MINUS:
return -prim(true);
case LP:
{
double e=my_expr(true);
if(curr_tok!=RP) return error(")expected");
(this->*get_token_p)(); // delete RP;
return e;
}
return error("primay expected");
}
}
Token_value expr::get_token(void)
{
char ch=0;
double power=1;
number_value=0.0;
do{
if(!(ch=string_expr[++i])) return curr_tok=END;
}while(ch!='\n' && isspace(ch));
switch(ch){
case 0:
return curr_tok=END;
case ';':
case '*':
case '/':
case '+':
case '-':
case '(':
case ')':
case '=':
case '^':
return curr_tok=Token_value(ch);
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.':
//string_expr.putback(ch);
while((isdigit((int)ch)))
{
number_value=number_value*10+(ch-'0');
ch=string_expr[++i];
}
if(ch=='.')
ch=string_expr[++i];
while((isdigit((int)ch)))
{
number_value=number_value*10+(ch-'0');
ch=string_expr[++i];
power*=10;
}
i--;
number_value=number_value/power;
// cout<<number_value<<endl;
return curr_tok=NUMBER;
default:
if(isalpha(ch)){
string_value=ch;
while((ch=string_expr[++i]) && isalnum(ch)) string_value.push_back(ch);
i--;
return curr_tok=NAME;
}
//error("bad token");
return curr_tok=PRINT;
}
}
Token_value expr::get_token_ios(void)
{
char ch=0;
do{
if(!cin.get(ch)) return curr_tok=END;
}while(ch!='\n' && isspace(ch));
switch(ch){
case 0:
return curr_tok=END;
case ';':
case '*':
case '/':
case '+':
case '-':
case '(':
case ')':
case '=':
case '^':
return curr_tok=Token_value(ch);
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.':
cin.putback(ch);
cin>>number_value;
return curr_tok=NUMBER;
default:
if(isalpha(ch)){
string_value=ch;
while(cin.get(ch) && isalnum(ch)) string_value.push_back(ch);
cin.putback(ch);
return curr_tok=NAME;
}
//error("bad token");
return curr_tok=PRINT;
}
}
void expr::jisuan(void)
{
get_token_p=&expr::get_token_ios;
while(cin){
(this->*get_token_p)();
if(curr_tok==END)break;
if(curr_tok==PRINT)continue;
cout<<my_expr(false)<<'\n';
// cout<<number_value<<endl;
}
//return 0;
}
double expr::eval(void)
{
get_token_p=&expr::get_token;
//while(string_expr){
(this->*get_token_p)();
//if(curr_tok==END)break;
//if(curr_tok==PRINT)continue;
return my_expr(false);
// cout<<number_value<<endl;
// }
//return 0;
}
int main(void)
{ /*
expr x("123/3+123*4-3");
cout<<"x="<<x.eval()<<"\n";
x.print();
*/
expr a("1+3+9/3");
cout<<a.eval()<<endl;
a.jisuan();
}

kikiwarm

没想到传说中的Lolita也光临本贴呀。

ywchen2000你那个是C++呀，我还没敢开始学。刚从china-pub买了The C++ Programming Language，天呀，怎么比K&R的TCPL厚那么多！看来不容易学。

贴代码用 ［code］ ［/code］吧，那样就有缩进而且不会有表情也可以有框架以免太长。

pointer

kikiwarm:
你是怎么运行的呢? 我这儿是测试过可以的.
这个程序从标准输入读取, 写到标准输出.
如:

1. 
   
2. ./cexp
   
3. 1+2*3-4   <-这是输入, 按Enter, Ctrl-D
   

复制代码

程序摘自编译原理的龙书, 不过原书是转换为后缀表达式的地方换为计算了.