关于putc

lambert_fan

C程序设计语言第八章155页：

1. #define putc(x, p) (--(p)->cnt >= 0 ? *(p)->ptr++ = (x) :  _flushbuf((x), p))

复制代码

cnt不是指缓冲区内剩余到字符数吗，  *(p)->ptr++ = (x)将x写入缓冲区之后cnt不应该增加吗？怎么还减减了呢--(p)->cnt >= 0

zzyong08

仅从代码来看，是剩余的空间数，也就是剩余的空间还能容放的字符数。

wb112200

应该是判断输入流缓存是否满了 如果满了 执行 覆盖操作 如果未满 直接将字符放入

amarant

cnt应该是count吧

rubylc_unix

回复 1# lambert_fan


    我觉得2，3楼说的是，不过我查了下，cnt到底是个啥呢

1. 在"stdio.h"中有如下定义
   
2. struct _iobuf {
   
3.         char *_ptr;   //文件输入的下一个位置
   
4.         int   _cnt;  //当前缓冲区的相对位置
   
5.         char *_base;  //指基础位置(即是文件的其始位置)
   
6.         int   _flag;  //文件标志
   
7.         int   _file;   //文件的有效性验证
   
8.         int   _charbuf;  //检查缓冲区状况,如果无缓冲区则不读取
   
9.         int   _bufsiz;   //文件的大小
   
10.         char *_tmpfname;  //临时文件名
    
11.         };
    
12. typedef struct _iobuf FILE;

复制代码

这里说的是当前缓冲区的相对位置，这个相对如何理解呢？

lambert_fan

回复 5# rubylc_unix


    据我现在的理解，cnt指缓冲区内剩余到字符数，对于_fillbuf和_flushbuf有不同到意思，在fillbuf中指已存入缓冲区的字符数，在flushbuf中指缓冲区剩余的空位置，原代码如下：

1. #include <unistd.h>
   
2. #include <fcntl.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #undef NULL
   
6. #define NULL 0
   
7. #define EOF (-1)
   
8. #define BUFSIZ 1024
   
9. #define OPEN_MAX 20
   
10. 
    
11. enum _flags {
    
12.         _READ = 01,
    
13.         _WRITE = 02,
    
14.         _UNBUF = 04,
    
15.         _EOF = 010,
    
16.         _ERR = 020,
    
17. };
    
18. 
    
19. typedef struct _iobuf {
    
20.         int cnt;
    
21.         char *ptr;
    
22.         char *base;
    
23.         int flag;
    
24.         int fd;
    
25. } FILE;
    
26. 
    
27. extern FILE _iob[OPEN_MAX];
    
28. 
    
29. FILE _iob[OPEN_MAX] = {
    
30.         {0, (char *)0, (char *)0, _READ, 0},
    
31.         {0, (char *)0, (char *)0, _WRITE, 1},
    
32.         {0, (char *)0, (char *)0, _WRITE | _UNBUF, 2},
    
33. };
    
34. 
    
35. #define stdin (&_iob[0])
    
36. #define stdout (&_iob[1])
    
37. #define stderr (&_iob[2])
    
38. 
    
39. int _fillbuf(FILE *);
    
40. int _flushbuf(int, FILE *);
    
41. 
    
42. #define feof(p) (((p)->flag & _EOF) != 0)
    
43. #define ferror(p) (((p)->flag & _ERR) != 0)
    
44. #define fileno(p) ((p)->fd)
    
45. 
    
46. #define getc(p) (--(p)->cnt >= 0 \
    
47.                 ? (unsigned char)*(p)->ptr++ : _fillbuf(p))
    
48. #define putc(x,p) (--(p)->cnt >= 0 \
    
49.                 ? *(p)->ptr++ = (x) : _flushbuf((x), p))
    
50. 
    
51. #define getchar() getc(stdin)
    
52. #define putchar(x) putc((x), stdout)
    
53. 
    
54. #define PERMS 0777
    
55. 
    
56. FILE *fopen(char *name, char *mode)
    
57. {
    
58.         int fd;
    
59.         FILE *fp;
    
60. 
    
61.         if (*mode != 'r' && *mode != 'w' && *mode != 'a')
    
62.                 return NULL;
    
63.         for (fp = _iob; fp < _iob + OPEN_MAX; fp++)
    
64.                 if ((fp->flag & (_READ | _WRITE)) == 0)
    
65.                         break;
    
66.         if (fp >= _iob + OPEN_MAX)
    
67.                 return NULL;
    
68. 
    
69.         if (*mode == 'w')
    
70.                 fd = creat(name, PERMS);
    
71.         else if (*mode == 'a') {
    
72.                 if ((fd = open(name, O_WRONLY)) == -1)
    
73.                         fd = creat(name, PERMS);
    
74.                 lseek(fd, 0L, 2);
    
75.         } else
    
76.                 fd = open(name, O_RDONLY, 0);
    
77.         if (fd == -1)
    
78.                 return NULL;
    
79.         fp->fd = fd;
    
80.         fp->cnt = 0;
    
81.         fp->base = NULL;
    
82.         fp->flag = (*mode == 'r') ? _READ : _WRITE;
    
83.         return fp;
    
84. }
    
85. 
    
86. int _fillbuf(FILE *fp)
    
87. {
    
88.         int bufsize;
    
89. 
    
90.         if ((fp->flag & (_READ | _EOF | _ERR)) != _READ)
    
91.                 return EOF;
    
92.         bufsize = (fp->flag & _UNBUF) ? 1 : BUFSIZ;
    
93.         if (fp->base == NULL)
    
94.                 if ((fp->base = (char *)malloc(bufsize)) == NULL)
    
95.                         return EOF;
    
96.         fp->ptr = fp->base;
    
97.         fp->cnt = read(fp->fd, fp->ptr, bufsize);
    
98.         if (--fp->cnt < 0) {
    
99.                 if (fp->cnt == -1)
    
100.                         fp->flag |= _EOF;
     
101.                 else
     
102.                         fp->flag |= _ERR;
     
103.                 fp->cnt = 0;
     
104.                 return EOF;
     
105.         }
     
106.         return (unsigned char) *fp->ptr++;
     
107. }
     
108. 
     
109. int _flushbuf(int x, FILE *fp)
     
110. {
     
111.         unsigned nc;
     
112.         int bufsize;
     
113. 
     
114.         if (fp < _iob || fp > _iob + OPEN_MAX)
     
115.                 return EOF;
     
116.         if ((fp->flag & (_WRITE | _ERR)) != _WRITE)
     
117.                 return EOF;
     
118.         bufsize = (fp->flag & _UNBUF) ? 1 : BUFSIZ;
     
119.         if (fp->base == NULL) {
     
120.                 if ((fp->base = (char *)malloc(bufsize)) == NULL) {
     
121.                         fp->flag |= _ERR;
     
122.                         return EOF;
     
123.                 }
     
124.         } else {
     
125.                 nc = fp->ptr - fp->base;
     
126.                 if (write(fp->fd, fp->base, nc) != nc) {
     
127.                         fp->flag |= _ERR;
     
128.                         return EOF;
     
129.                 }
     
130.         }
     
131.         fp->ptr = fp->base;
     
132.         *fp->ptr++ = x;
     
133.         fp->cnt = bufsize - 1;
     
134. 
     
135.         return x;
     
136. 
     
137. }
     
138. 
     
139. int main()
     
140. {
     
141.         FILE *fp;
     
142.         int c;
     
143. 
     
144.         if ((fp = fopen("test.c", "r")) == NULL)
     
145.                 return EOF;
     
146.         while ((c = getc(fp)) != EOF) {
     
147.                 //write(1, &c, 1);
     
148.                 putchar(c);
     
149.         }
     
150. }

复制代码