标准I/O库对每个I/O流自动进行缓冲，从而避免了应用程序为了减少read和write系统调用而设置合适的缓冲区长度。
标准I/O提供了三种类型的缓冲
我们下来看一个《unix环境高级编程》上的一个输出标准输入，标准输出，标准出错和普通文件的缓冲信息的例子
4 void pr_stdio(char *,FILE *);
5
6 int main(void){
7 FILE *fp;
8 fputs("entry any character\n",stdout);
9 if(getchar()==EOF){
10 printf("getchar error\n");
11 exit(1);
12 }
13 fputs("one line to standard error\n",stderr);
14
15 pr_stdio("stdin",stdin);
16 pr_stdio("stdout",stdout);
17 pr_stdio("stderr",stderr);
18
19 if((fp=fopen("test","r+"))==NULL){
20 perror("fopen error");
21 exit(1);
22 }
23 if(getc(fp)==EOF){
24 printf("getc error\n");
25 exit(1);
26 }
27 pr_stdio("test",fp);
28
29 exit(0);
30 }
31
32 void pr_stdio(char *name,FILE *fp){
33 printf("stream=%s ",name);
34
35 if(fp->_IO_file_flags & _IO_UNBUFFERED)
36 printf("unbuffered");
37 else if(fp->_IO_file_flags & _IO_LINE_BUF)
38 printf("line buffered");
39 else
40 printf("fully buffered");
41 printf(", buf size=%d\n",fp->_IO_buf_end-fp->_IO_buf_base);
42 }
我们直接看输出：
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
entry any character
one line to standard error
stream=stdin line buffered, buf size=1024
stream=stdout line buffered, buf size=1024
stream=stderr unbuffered, buf size=1
stream=test fully buffered, buf size=4096
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out std.out 2>std.err //标准输入，输出重定向到普通文件
feng@ubuntu:~/learn_linux_c_second/chapter_5$ cat std.err
one line to standard error
feng@ubuntu:~/learn_linux_c_second/chapter_5$ cat std.out
entry any character
stream=stdin fully buffered, buf size=4096
stream=stdout fully buffered, buf size=4096
stream=stderr unbuffered, buf size=1
stream=test fully buffered, buf size=4096
feng@ubuntu:~/learn_linux_c_second/chapter_5$
针对上面的代码，我们需要做一下说明，在打印缓冲信息之前我们对每个i/o流都执行了i/o操作，是因为第一个i/o操作会造成该流的缓冲分配，如果
不执行一次i/o操作，我们只能从知道缓冲类型，而不得到缓冲大小。上面的test为一个普通文件。
从输出中我们又以下结论：
系统默认情况是标准输入，输出 连接至终端时，他们是行缓冲的，缓冲大小为1024.当这两个留被重定向到普通文件是他们是全缓冲的，缓冲大小为4096
标准出错一直都是非缓冲
普通文件默认是全缓冲。
下面我们就来一一解释这些街结论。
1全缓冲：
这种情况下在填满标准I/O缓冲区后才进行实际的I/O操作。对于驻留在磁盘上的文件通常是由标准I/O实施全缓冲的。重向到普通文件的标准输入和输出也是全缓冲的
什么叫填满标准I/O缓冲区呢，就是说，标准I/O维护一个适当大小的缓冲区，当我们调用fwrite这类的标准I/O函数时，他们总是先写到内存中的标准I/O维护的缓冲区，当这个缓冲区被填满或调用fflush冲洗缓冲区时才实际调用write系统调用去写磁盘（当然这里即使是实际i/o操作也不一定真的写到磁盘了，因为计算机内都有高速缓存）
我们来直接看测试程序吧：
1 #include
2 #include
3 #include
4
5 #define COUNT 500
6
7 int main(void){
8 FILE *fp=fopen("test","w+");
9 if(fp==NULL){
10 perror("fopen error");
11 exit(1);
12 }
13
14 int i;
15 for(i=0;i
16 if(fwrite("c",sizeof(char),1,fp)!=1){
17 printf("write error\n");
18 exit(1);
19 }
20 }
21 // fflush(fp);
22 int fd=fileno(fp);
23 lseek(fd,0,SEEK_SET);
24 char buf[2];
25 int nreads;
26 printf("\n %c %c\n",buf[0],buf[1]);
27 nreads=read(fd,buf,2);
28 if(nreads==-1){
29 perror("read error");
30 exit(0);
31 }
32 printf("\n %c %c\n",buf[0],buf[1]);
33
34 exit(0);
35 }
分析：我们用标准I/O函数写了500个字幕到普通文件test中，（前面我们已经知道普通文件默认是全缓冲的大小为4096），然后我们用read系统调用去读文件内容
。因为我们只写了500个字符，那么标准i/o缓冲区未被写满，我们也没有调用fflush，那么我们可以猜想，我们是读不到任何数据的
我们看下输出：
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
p ?
read 0 characters
p ?
这里证明我们的猜想是正确的。这里有输出是应为我们并未初始化数组，所以输出的内容是该内存位置之前存在的数据。我们未初始化的原因也是用两个输出来前后对比
这里需要强调一点的是：我们的读操作 不能调用标准I/O的fread，因为我们的数据是写在缓冲区的，这是缓冲区有数据，那么fread就会从缓冲区读，就会读出数据
所以我们用fileno(fp),得到该流对应的底层文件描述符，然后用该描述符直接去读文件内容。
注意21行。如果我们执行这句 fflush会怎么样呢。我们测试下：
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
{ ?
read 2 characters
c c
情况如我们上面说的 ，调用fflush会强制冲洗缓冲区的内容，就会导致调用系统write去写文件，那么我们就能从文件中读到数据了
现在我们在把第五行的 COUNT 宏定义改成5000（>4096），看下结果会怎么样。注意我们不执行fflush。因为我们要测试缓冲区满会不会造成冲洗，所以要排除fflush强制冲洗的情况
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
| ?
read 2 characters
c c
结果也不出所料。由于我们想缓冲区写入5000个数据，造成缓冲区满了，所以被冲洗，执行了实际i/o操作，所以我们也就能从文件中读到数据了
2行缓冲：
在这种情况下，默认标准输入输出中遇到换行符时，标准i/o执行实际i/o操作。
直接例子：
5 int main(void){
6
7 int i;
8 for(i=0;i
9 if(fwrite("a",sizeof(char),1,stdout)!=1){
10 printf("fwrite error\n");
11 exit(1);
12 }
13 }
14 printf("\n");
15 for(i=0;i
16 if(fwrite("b",sizeof(char),1,stdout)!=1){
17 printf("fwrite error");
18 exit(1);
19 }
20 }
21 //fflush(stdout);
22 while(1);
23 exit(0);
24
25 }
~
输出：
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
aaaaa
我们会发下程序一直在这里循环但是只输出了a 但是b并未输出。因为标准i/o默认是链接到终端的是行缓冲（上面得到大小为1024），他们遇到换行符，或缓冲区满，或调用fflush时才会导致冲洗缓冲区，所以我们写入5个 a 后打印了一个换行符，于是缓冲区被冲洗,a被输出，但是我们
之后只写了5个b 缓冲区未满，我们也没用调用fflush，所以b不会输出。
如果我们在 写完5个 b 后调用一个fflush可以猜想b也是会输出的，我们测试一下
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
aaaaa
bbbbb
的确如此，程序还是停在循环处，但这时候b 也被输出。
同样的如果我们写 大于1024个b，即使不调用fflush，b还是会被输出。这里我们就不测试了。总不能搞的屏幕全是字母b吧
需要注意的一点就是 当标准输入输出重定向到普通文件时，就会变成全缓冲（最开始的测试结果已经说明了这个特性）
3非缓冲：
这个就好理解了，就是说标准i/o不会对其进行缓冲：
做个测试：
4 int main(void){
5 int i;
6 for(i=0;i<5;i++){
7 if(fwrite("a",sizeof(char),1,stderr)!=1){
8 printf("fwrite error");
9 exit(1);
10 }
11 }
12 while(1);
13 }
输出：
feng@ubuntu:~/learn_linux_c_second/chapter_5$ ./a.out
aaaaa
我们没有做任何处理，但是标准出错还是输出了a。这就说明对于标准出错是非缓冲的。即使是被重定向，标准输出还是非缓冲的（最开始的那个理解的结果已经说明）
这也容易理解。任何时候只要有错误，我们都需要立刻知道。所以他是非缓冲的
阅读(807) | 评论(0) | 转发(0) |
