浅谈标准I/O缓冲区

分手后的思念是犯贱 2022-05-24 00:11 129阅读 0赞

标准I/O库提供缓冲的目的是尽可能地减少使用read和write调用的次数。它也对每个I/O流自动地进行缓冲管理，从而避免了应用程序需要考虑这一点所带来的麻烦。不幸的是，标准I/O库最令人迷惑的也是它的缓冲。

标准I/O提供了三种类型的缓冲：

> 1、全缓冲：
> 
> 在填满标准I/O缓冲区后才进行实际I/O操作。常规文件（如普通文本文件）通常是全缓冲的。
> 
>   
> 
> 
> 2、行缓冲：
> 
> 当在输入和输出中遇到换行符时，标准I/O库执行I/O操作。这允许我们一次输出一个字符，但只有在写了一行之后才进行实际I/O操作。标准输入和标准输出对应终端设备（如屏幕）时通常是行缓冲的。
> 
>   
> 
> 
> 3、不带缓冲：
> 
> 用户程序每次调库函数做写操作都要通过系统调用写回内核（如系统调用函数）。标准错误输出通常是无缓冲的，这样用户程序产生的错误信息可以尽快输出到设备。

下面是各个缓冲区的验证。

# 全缓冲： #

\[cpp\] [view plain][] [copy][view plain]

1.  **int** main(**int** argc, **char** \*argv\[\]) 
2.  \{ 
3.  **FILE** \*fp = NULL; 
4.  // 读写方式打开，文件不存在则创建
5.   fp = fopen("sunplusedu.txt", "w+"); 
6.  **if**(NULL == fp) 
7.   \{ 
8.   printf("open error\\n"); 
9.  **return** 1; 
10.  \} 
11. **char** \*str = "sunplusedu\\n"; 
12.  fwrite(str, 1, strlen(str), fp); // 往文件写内容
13. **while**(1); // 程序阻塞在这里
14. 
15. **return** 0; 
16. \}

运行程序发现，sunplusedu.txt并没有内容。因为常规文件通常是全缓冲的，只有缓冲区满了后，才会把内容写到文件中。接下来，我们改一下上面那个例子。

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  \#include <string.h>
3.  
4.  **int** main(**int** argc, **char** \*argv\[\]) 
5.  \{ 
6.  **FILE** \*fp = NULL; 
7.  // 读写方式打开，文件不存在则创建
8.   fp = fopen("sunplusedu.txt", "w+"); 
9.  **if**(NULL == fp) 
10.  \{ 
11.  printf("open error\\n"); 
12. **return** 1; 
13.  \} 
14. **char** \*str = "sunplusedu\\n"; 
15. **int** i = 0; 
16. **while**(i <= 512)\{ // 缓冲区大小不确定，i的大小只是一个调试值
17.  fwrite(str, 1, strlen(str), fp); // 往文件写内容
18.  i++; 
19.  \} 
20. **while**(1); // 程序阻塞在这里
21. 
22. **return** 0; 
23. \}

上面的例子是循环给文件写内容，让缓冲区有填满的可能，结果发现，文件是有内容的。实际上要想成功给文件写进内容，除了缓冲区填满，还有别的方法。

1）人为关闭文件，就算缓冲区没有填满，内容也会写进文件

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  \#include <string.h>
3.  
4.  **int** main(**int** argc, **char** \*argv\[\]) 
5.  \{ 
6.  **FILE** \*fp = NULL; 
7.  // 读写方式打开，文件不存在则创建
8.   fp = fopen("sunplusedu.txt", "w+"); 
9.  **if**(NULL == fp) 
10.  \{ 
11.  printf("open error\\n"); 
12. **return** 1; 
13.  \} 
14. **char** \*str = "sunplusedu\\n"; 
15.  fwrite(str, 1, strlen(str), fp); // 往文件写内容
16.  fclose(fp); // 人为关闭文件，就算缓冲区没有填满，内容也会写进文件
17. 
18. **while**(1); // 程序阻塞在这里
19. 
20. **return** 0; 
21. \}

2）程序正常结束，就算缓冲区没有填满，没有关闭文件，内容也会写进文件。

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  \#include <string.h>
3.  
4.  **int** main(**int** argc, **char** \*argv\[\]) 
5.  \{ 
6.  **FILE** \*fp = NULL; 
7.  // 读写方式打开，文件不存在则创建
8.   fp = fopen("sunplusedu.txt", "w+"); 
9.  **if**(NULL == fp) 
10.  \{ 
11.  printf("open error\\n"); 
12. **return** 1; 
13.  \} 
14. **char** \*str = "sunplusedu\\n"; 
15.  fwrite(str, 1, strlen(str), fp); // 往文件写内容
16. 
17. **return** 0; 
18. // 程序正常结束，就算缓冲区没有填满，没有关闭文件，内容也会写进文件。
19. \}

# 行缓冲： #

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  
3.  **int** main(**int** argc, **char** \*argv\[\]) 
4.  \{ 
5.   printf("hello sunplusedu"); 
6.  **while**(1); 
7.  
8.  **return** 0; 
9.  \}

运行这个程序，会发现 hello sunplusedu 并没有打印到屏幕上。因为标准输入和标准输出对应终端设备时通常是行缓冲的，当在输入和输出中遇到换行符时，标准I/O库执行I/O操作。如下：

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  
3.  **int** main(**int** argc, **char** \*argv\[\]) 
4.  \{ 
5.   printf("hello sunplusedu\\n"); 
6.  **while**(1); 
7.  
8.  **return** 0; 
9.  \}

除了遇到换行符，还有别的方法可以执行I/O操作。

1）缓冲区填满

\[cpp\] [view plain][] [copy][view plain]

1.  **int** main(**int** argc, **char** \*argv\[\]) 
2.  \{ 
3.  **while**(1)\{ // 循环打印，总有缓冲区填满的可能
4.   printf("hello sunplusedu"); 
5.   \} 
6.  **while**(1); 
7.  
8.  **return** 0; 
9.  \}

2）人为刷新缓冲区

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  
3.  **int** main(**int** argc, **char** \*argv\[\]) 
4.  \{ 
5.   printf("hello sunplusedu"); 
6.   fflush(stdout); // 人为刷新
7.  
8.  **while**(1); 
9.  
10. **return** 0; 
11. \}

3）程序正常结束

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <stdio.h>
2.  
3.  **int** main(**int** argc, **char** \*argv\[\]) 
4.  \{ 
5.   printf("hello sunplusedu"); 
6.  
7.  **return** 0; 
8.  // 程序正常结束
9.  \}

# 不带缓冲： #

\[cpp\] [view plain][] [copy][view plain]

1.  \#include <unistd.h>
2.  \#include <string.h>
3.  
4.  **int** main(**int** argc, **char** \*argv\[\]) 
5.  \{ 
6.  **char** \*str = "hello sunplusedu.com"; 
7.  // 有没有\\n，缓冲区有没有填满，都没关系
8.   write(1, str, strlen(str)); // 往标准输出写内容
9.  **while**(1); 
10. 
11. **return** 0; 
12. \}

转自：https://blog.csdn.net/tennysonsky/article/details/43490985

[view plain]: https://blog.csdn.net/tennysonsky/article/details/43490985#

发表评论取消回复

表情：

评论列表（有 0 条评论，129人围观）

还没有评论，来说两句吧...

相关阅读

相关 python标准库:math浅谈

![e3ede86617cfaa095a493baf23aa85ca.jpeg][] 转自：[微点阅读][Link 1] [https://www.weidianyuedu.

野性酷女/ 2024年03月26日 21:22/ 0 赞/ 45 阅读

相关什么是标准io缓冲区_缓冲区机制详解

![9c31d90092049654ebdbfdaf1dbb56b8.png][] 在最近的几场比赛中，部分赛题牵扯到缓冲区的知识，之前对这块的知识还不够特别的理解，所以抽时

傷城~/ 2022年10月24日 02:42/ 0 赞/ 296 阅读

相关浅谈计算密集型与IO密集型

计算密集型与IO密集型这个概念，在面试的时候可能会被问到，主要是在多线程环境中，如何设置线程数，让CPU充分利用，跑出最高效率。计算密集型：这一类主要是在线

快来打我*/ 2022年10月07日 13:54/ 0 赞/ 190 阅读

相关 [转]浅谈缓冲区溢出之栈溢出

[浅谈缓冲区溢出之栈溢出][Link 1] By [浅墨][Link 2] 发表于 2012-12-02 有段时间没有用wind

柔光的暖阳◎/ 2022年08月19日 04:53/ 0 赞/ 199 阅读

相关记一个关于标准IO流缓冲区的有趣例子

在编程时无意中发现一个有趣的现象，经过分析应该是标准IO流的缓冲区机制引起的。有如下一段代码 include <stdio.h> include <un

太过爱你忘了你带给我的痛/ 2022年06月04日 03:38/ 0 赞/ 149 阅读

相关 iOS 核心动画 Core Animation浅谈

> 代码地址如下： > [http://www.demodashi.com/demo/11603.html][http_www.demodashi.com_demo_116

约定不等于承诺〃/ 2022年05月30日 04:21/ 0 赞/ 315 阅读

相关浅谈C语言缓冲区问题

这里是转载，个人感觉他写的真的很不错。 [缓冲区问题详解][Link 1] scanf中比较少用的是 \[ 扫描字符集合, ^ 类似数学中的补集。\忽略读到的内容，\

迷南。/ 2022年05月28日 12:11/ 0 赞/ 277 阅读

相关浅谈标准I/O缓冲区

标准I/O库提供缓冲的目的是尽可能地减少使用read和write调用的次数。它也对每个I/O流自动地进行缓冲管理，从而避免了应用程序需要考虑这一点所带来的麻烦。不幸的是，标准I

分手后的思念是犯贱/ 2022年05月24日 00:11/ 0 赞/ 130 阅读

相关浅谈 iOS Device ID 的修改

Dark side of the Force 最近有一篇 [文章][Link 1] 介绍了如何实现 AppStore App 自动下载，笔者看后收获良多。不过文中只介绍了如何

向右看齐/ 2022年03月16日 14:58/ 0 赞/ 1071 阅读

相关浅谈 Linux IO

公众号关注「开源Linux」回复「学习」，有我为您特别筛选的学习资料~ ![format_png][] 来源于：360云计算 1 前言 Linux

本是古典何须时尚/ 2021年09月07日 06:12/ 0 赞/ 377 阅读