getchar()从键盘获取输入包含了换行符？

lylesong

这个是书上的一个例子，是一个逆波兰式计算器，
我把这个例子拿来运行后，最开始发现一旦入栈，马上就又出栈了，后面找了很久，发现每次都会输出换行符 '\n'，就会运行switch 里面的 case '\n': 语句，而那里又调用了pop()函数，所以就会导致入栈马上又出栈了，
我注释掉这一段后，在'+'这种情况下运行程序，发现可以得到正确的加法结果，但是在输出中，还是有'\n'这种情况，因为没有了这种case，所以就跳转到default情况里面了，就会导致每次输入，都会有对应default输出，这个问题是怎么回事呢？
我检查了getop()函数，实在找不到问题在哪里，希望大家能帮我分析一下，谢谢

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<ctype.h>
   
4. 
   
5. #define MAXOP 100
   
6. #define NUMBER '0'
   
7. #define MAXVAL 100
   
8. #define BUFSIZE 100
   
9. 
   
10. int getop(char []);
    
11. void push(double);
    
12. double pop(void);
    
13. int getch(void);
    
14. void ungetch(int);
    
15. 
    
16. int sp = 0;
    
17. double val[MAXVAL];
    
18. int bufp = 0;
    
19. char buf[BUFSIZE];
    
20. 
    
21. int main()
    
22. {
    
23.         int type;
    
24.         double op2;
    
25.         char s[MAXOP];
    
26. 
    
27.         while((type = getop(s)) != EOF)
    
28.         {
    
29.                 switch(type)
    
30.                 {
    
31.                         case NUMBER:
    
32.                                 push(atof(s));
    
33.                                 printf("now the sp result is:%d\n",sp);
    
34.                                 break;
    
35.                         case '+':
    
36.                                 push(pop() + pop());
    
37.                                 printf("now the sp result is:%d\n",sp);
    
38.                                 printf("now the + result is:%f\n",pop());
    
39.                                 break;
    
40.                         case '*':
    
41.                                 push(pop() * pop());
    
42.                                 printf("now the sp result is:%d\n",sp);
    
43.                                 break;
    
44.                         case '-':
    
45.                                 op2 = pop();
    
46.                                 push(pop() - op2);
    
47.                                 printf("now the sp result is:%d\n",sp);
    
48.                                 break;
    
49.                         case '/':
    
50.                                 op2 = pop();
    
51.                                 if(op2 != 0.0)
    
52.                                         push(pop() / op2);
    
53.                                 else
    
54.                                         printf("error:zero divisor\n");
    
55.                                 break;
    
56.                         //case '\n':
    
57.                         //        printf("\t%.8g\n",pop());
    
58.                 //                printf("now the sp result is:%d\n",sp);
    
59.                 //                break;
    
60.                         default:
    
61.                                 printf("error:unknown command %s\n",s);
    
62.                                 break;
    
63.                         }
    
64.         }
    
65.         return 0;
    
66. }
    
67. 
    
68. void push(double f)
    
69. {
    
70.         if(sp < MAXVAL)
    
71.                 val[sp++] = f;
    
72.         else
    
73.                 printf("error:stack full,can't push %g\n",f);
    
74. }
    
75. 
    
76. double pop(void)
    
77. {
    
78.         if(sp > 0)
    
79.                 return val[--sp];
    
80.         else
    
81.         {
    
82.                 printf("error:stack empty\n");
    
83.                 return 0.0;
    
84.         }
    
85. }
    
86. 
    
87. int getop(char s[])
    
88. {
    
89.         int i, c;
    
90.         while((s[0] = c = getch()) == ' ' || c == '\t')
    
91.                 ;
    
92.         s[1] = '\0';
    
93.         if(!isdigit(c) && c != '.')
    
94.                 return c;
    
95.         i = 0;
    
96.         if(isdigit(c))
    
97.                 while(isdigit(s[++i] = c = getch()))
    
98.                         ;
    
99.         if(c == '.')
    
100.                 while(isdigit(s[++i] = c = getch()))
     
101.                         ;
     
102.         s[i] = '\0';
     
103.         if(c != EOF)
     
104.                 ungetch(c);
     
105.         return NUMBER;
     
106. }
     
107. 
     
108. int getch(void)
     
109. {
     
110.         return (bufp > 0) ? buf[--bufp] : getchar();
     
111. }
     
112. 
     
113. void ungetch(int c)
     
114. {
     
115.         if(bufp >= BUFSIZE)
     
116.                 printf("ungetch:too many characters\n");
     
117.         else
     
118.                 buf[bufp++] = c;
     
119. }

复制代码

用gdb调试了一下，发现这里的运行过程是这样的，所以我还是无法判断到底哪里出了问题，

1. (gdb) b 31
   
2. Breakpoint 1 at 0x804856d: file polish.c, line 31.
   
3. (gdb) run
   
4. Starting program: /home/song/cprogram/polish/polish
   
5. 4
   
6. 
   
7. Breakpoint 1, main () at polish.c:32
   
8. 32                                        push(atof(s));
   
9. (gdb) n
   
10. 33                                        printf("now the sp result is:%d\n",sp);
    
11. (gdb) n
    
12. now the sp result is:1
    
13. 34                                        break;
    
14. (gdb) n
    
15. 27                while((type = getop(s)) != EOF)
    
16. (gdb) n
    
17. 29                        switch(type)
    
18. (gdb) n
    
19. 61                                        printf("error:unknown command %s\n",s);
    

复制代码

hanzhenlll

getch()吃回车么,好像不清楚......印象中getchar() 吃的....       最好用fgets || fgetc (stdin) 来替换

   while((s[0] = c = getch()) == ' ' || c == '\t')

这句有错吗?  你确定是 ||的关系?

lylesong

回复 2# hanzhenlll


    这个是 K&R书上的例子，我原样写下来的，虽然可以改写，我还是想知道这个问题是咋个回事，
按理说，原书上的代码的意思应该是，
输入数字，按回车，就把这个数字压入栈中，
输入运算符号，按回车，运算相对操作数，运算结果压入栈中，
单独按回车，那么，就运行 case '\n': 的情况，输出运算结果，
现在的结果是，每次输入，在压入栈中的时候，也会得到一个不知从哪里来的 换行符'\n'，
使得 while((type = getop(s)) != EOF) 再次运行，这次type == '\n' 了。

1. Reading symbols from /home/song/cprogram/polish/polish...done.
   
2. (gdb) b 31
   
3. Breakpoint 1 at 0x804856d: file polish.c, line 31.
   
4. (gdb) run
   
5. Starting program: /home/song/cprogram/polish/polish
   
6. 4
   
7. /* 第一次输入数字4，后面全部自动运行了，可以看到，在等待下一个操作数输入时，while循环自动运行了一次，这次的type == '\n' */
   
8. Breakpoint 1, main () at polish.c:32
   
9. 32                                        push(atof(s));
   
10. (gdb) n
    
11. 33                                        printf("now the sp result is:%d\n",sp);
    
12. (gdb)
    
13. now the sp result is:1
    
14. 34                                        break;
    
15. (gdb)
    
16. 27                while((type = getop(s)) != EOF)
    
17. (gdb)
    
18. 29                        switch(type)
    
19. (gdb)
    
20. 61                                        printf("error:unknown command %s\n",s);
    
21. (gdb)
    
22. error:unknown command
    
23. 
    
24. 27                while((type = getop(s)) != EOF)
    
25. (gdb)
    

复制代码

hanzhenlll

每次调用输入输入  也就是getchar()   用一下 fflush(stdin) 清空一下标准输入...避免回车被下一个getchar()吃掉

书上怎么了，不要迷信书都是对的

lylesong

hanzhenlll 发表于 2012-01-18 11:54
每次调用输入输入  也就是getchar()   用一下 fflush(stdin) 清空一下标准输入...避免回车被下一个getchar( ...

额，没有用过fflush(),看了下说明，int  fflush(FILE *stream);
这个应该加在哪里合适啊，我试着修改了getch()函数，还是有原来那个错误。

108 int getch(void)
109 {
110     char result;
111     result = (bufp > 0) ? buf[--bufp] : getchar();
112     fflush(stdin);
113     return result;
114 }


我觉得这么牛逼的一本书，c语言的圣经，如果有错，也许早就被指出来放在勘误里面了，可是勘误里面没有，
前面那么多人用这个书都没遇到这个问题，我遇到了，或许不是书的问题，是我的问题？

lylesong

回复 4# hanzhenlll


    额，找到原因了，是我自己输入格式上的问题，
按照那个要求来，如果要计算 4+3,那么就输入  4 3 + 回车。谢谢hanzhenlll ，让我学到了一个新函数。

JohnBull

lylesong 发表于 2012-01-18 13:08
回复 4# hanzhenlll

学新函数。还是首先要好好看手册

man 3 fflush

CONFORMING TO
       C89, C99, POSIX.1-2001, POSIX.1-2008.

       The standards do not specify the  behavior  for  input  streams.   Most
       other implementations behave the same as Linux.