Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1589086
  • 博文数量: 695
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4027
  • 用 户 组: 普通用户
  • 注册时间: 2013-11-20 21:22
文章分类

全部博文(695)

文章存档

2018年(18)

2017年(74)

2016年(170)

2015年(102)

2014年(276)

2013年(55)

分类: C/C++

2013-12-18 21:58:17

标准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。这就说明对于标准出错是非缓冲的。即使是被重定向,标准输出还是非缓冲的(最开始的那个理解的结果已经说明)
这也容易理解。任何时候只要有错误,我们都需要立刻知道。所以他是非缓冲的
阅读(503) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~