Linux - 用户级缓冲区和系统缓冲区 - 初步理解Linux当中文件系统

前言
 

文件系统

我们先来看两个例子：
 

这个程序输出：

此时的输出也满足的我们预期。

 我们也可以把 程序执行结果，输出重定向到 一个文件当中:

 当我们在代码的结尾处，创建了子进程，那么输出应该还是和上述是一样的：

 此时，我们把 这个程序的输出结果 ">" 重定向到 一个文件当中，为了验证，所以，我们把之前在文件当中保存的 数据先删除：

然后，在进行重定向操作（其实 ">" 这个重定向本来就可以做到 清空文件的作用，这里只不过是 为了 分步骤来看，更加可观）：

发现，此时的结果，在文件当中输出和之前不一样了。 

 上述的输出结果，看上去和之前的输出结果没什么关系，也不是单纯的输出了两遍，因为只输出了 7 行 而不是 8 行。

我们发现，除了 write（）系统调用接口函数之外，C 库当中都是按照我们调用的顺序 调用了两遍。而且，wirte（）函数的打印顺序，和之前相比也是不一样的。

 说明，系统调用接口，没有受到我们 fork（）函数影响。

 出现上述的原因，就和 缓冲区脱不了干系了。

缓冲区

先看下述 例子 ：

上述的 三个函数 都是 在 stdout 这个文件当中输出数据，当他们输出完毕之后，我再去 把 1 号文件也就对应着 stdout 这个文件关闭了，然后程序执行结束，你再猜猜 此时的输出结果是什么？

发现，此时是什么结果都没有输出的，同样，重定向到 log.txt 文件当中也是没有输出的。

上述的是 3 个 C库函数，如果是 系统调用接口呢？此时我们把 write（）系统调用接口调用：

输出：

发现居然 成功输出 了。 

在 C 当中封装的要调用到 硬件的 函数，底层都是要调用 系统调用接口的，比如上述的函数，都是要调用 write（）函数的。

 都是把对应的数据，传入到 write（）系统调用接口，然后通过系统调用接口 来 输入到缓冲区当中。

其实，上述使用的 3 个C库函数，其实是已经在缓冲区当中输入数据了的。

一个文件，肯定是提供了 自己 操作系统级别的缓冲区。这个缓冲器就是这个文件的 文件缓冲区。

但是，3 个C库函数   写入的缓冲区肯定不是 系统级别的缓冲区，如果是系统级别的缓冲区的话，程序执行结束之时，就会刷新缓冲区，我们就会看到对应的输出结果。

这就是为什么 write（）系统调用接口可以看到 输出结果。write（）函数，是直接向 传入的文件的 对应 文件缓冲区当中 写入数据。到最后刷新文件缓冲区之时，就会把数据刷新到文件当中。

而且，像 printf / fprintf / fwrite / fputs ····· 这些函数，不是直接向文件缓冲区当中去刷新数据，因为 文件缓冲区是属于内核的，在语言级别 封装的 函数是不能直接访问到的，中间还有层级。（反证：如果 printf / fprintf / fwrite / fputs ····· 这些函数 已经把数据拷贝到 文件缓冲区当中了，当我们调用 close（）函数之时，比如 close（1），就会把 1 号文件 对应的 文件缓冲区当中的数据 刷新 到磁盘当中。 但是，我们并没有看到 输出结果。）

 那么 ，语言层级的 函数，不直接向 系统级别的 缓冲区当中写入数据，那么数据究竟被写入到那里了呢？

其实，像 C/C++ 语言，是有自己的 语言层级的 缓冲区 的。这个缓冲区是 用户级别的 缓冲区。

所以，像 printf / fprintf / fwrite / fputs ····· 这些函数 在向文件当中写入数据之时，并不是直接把数据写到 系统级别的缓冲区当中，而是先写入到 语言层级的 缓冲区 当中。

只有当在 合适时机，比如 遇到了强制刷新缓冲区，fclose（）函数，或者是在字符串当中有 '\n'  ····· 等等时机，此时 才会调用 write（）函数把 语言层级的 缓冲区 当中的数据，写入到 系统缓冲区当中。

 所以，在 开始 close（1）关闭1号文件 C 库函数没有输出的原因是：

  •              在 C语言当中的缓冲区刷新之前，1 号 文件 也就是 stdout 文件 已经被关闭了，当程序解释之时， C语言当中的缓冲区 想要刷新 其中的数据到 1 号文件的 文件缓冲区之时，在这个进程当中就找不到这 1 号文件了。

所以，此时如果我们把 三个 C库函数当中要输出的字符串都 ，就可以输出数据了。

输出：
 

 为什么 在字符串当中  带上 '\n' 的话 就 可以 刷新呢？

因为 显示器文件的刷新方案是 行刷新。所以在 类似 printf（）函数执行之时，识别到 字符串当中有 '\n' ，遇到 '\n' 就会立即把 C语言 缓冲区当中的数据 刷新出去。

 所以，刷新的本质就是  通过 1 号文件 + write（）系统接口的方式，写入到内核当中的 系统级别的 缓冲区当中。

所以，例如 exit（） 和 _exit（）两个函数是有区别的！！

exit（）是C当中通过 _exit（）函数封装的一个函数，而 _exit（）此时 真正实现 进程退出的 系统调用接口；exit（）底层当中 一定 有_exit（）的调用。

在理解上述 用户级别 缓冲区 和 操作系统级别的缓冲区的 区别之后，你应该就会明白这两个函数有什么不同。

之所以 exit（） 函数能刷新 C语言缓冲区，是因为 exit（）函数是 在 C语言当中通过 _exit（）函数封装的一个 函数（  fflush（strout）； _exit()  ），他能看到 这个层次 C语言缓冲区。而 _exit() 不能刷新 C语言缓冲区是因为 _exit（）是底层系统调用接口，它的层级是在底层，它看不到  在用户层级的 C语言缓冲区。

所以，到现在，你可以简单 理解的为：只要是 数据被刷新到 系统缓冲区当中了，也就是 数据被刷新到了内核当中，数据就可以到达硬件了。 

 缓冲区的刷新问题

 主要分为三种方式进行刷新：

  • 无缓冲 --- 直接进行刷新，也就是收到数据就马上把这个数据给刷新出去。比如调用 prinf（）函数，调用 printf（）函数结束 就 立即把 缓冲区当中的数据刷新 到内核当中。
  • 行缓冲 --- 就像上述的 显示器文件一样，一行一行的进行输出。不管当前缓冲区当中有多少个数据，只要没有 '\n' 类似的换行符，就会一直在 缓冲区当中等待，只要 缓冲区当中读到了第一个 '\n' 类似的换行符，才会把 缓冲区当中的 数据刷到 内核当中。    、
  • 全缓冲 --- 什么都不认，无论输入什么数据到 缓冲区当中，都要进行等待，直到 把 缓冲区当中的数据写满了，才会把 缓冲区当中的数据 刷新到 内核当中。

     在文件缓冲区当中使用的刷新方式是 全缓冲，也就是，把缓冲区当中写满才会 把数据写到 文件缓冲区当中。

为什么文件要使用 全缓冲呢？（因为，除了 显示器文件，其他在磁盘当中存储的文件，不是直接拿给 用户 或者是 操作系统来直接查看的。没有 显示器文件那种需求。）

当然，当进程退出之时，也就刷新 C 语言缓冲区。像我们在 调用 printf（"hello Linux!"）; 在这个语句当中是没有 '\n' 的，但是，在最后还是会给我们刷新到 strout 文件当中让我们看到。

就是因为 当进程退出的之时，也会刷新缓冲区。

所以，缓冲区当中的刷新不一样必须按照上述的 三种方式来刷新。

为什么在 语言 层面会多出一个 语言层面的缓冲区呢？

其实，在语言层面的缓冲区就跟 快递公司一样，当我们先寄出一个包裹的时候，只需要到快递公司，把信息填好，快递公司就可以帮我们把东西送到目的地。

如果没有快递公司，那么我们可能就要自己亲自去送到 目的地，那么在此期间，就会非常的耗费时间。

有了快递公司，我们可以很方便的 把 "送东西"这个操作，交给快递公司来做，而我们就可以去干自己的事情。

快递公司在此处就相当于是 语言缓冲区，它解决的事 程序运行的效率问题。注意解决的不是 操作系统当中的效率，而是程序自己在运行之时的效率问题，这个数据要 放到那个 文件当中，该怎么放入，走什么流程，还是上述所说的流程，只不过，把这个流程不用程序自己做了，交给 语言缓冲区来做就可以了。所以提高的是程序的运行效率。

所以我们调用 printf（）/ fprintf（）···· 这些需要向文件当做写入 数据的 函数，才能很快的就调用个完。

要不是，在用户层面，要想访问到 底层当中硬件设备，中间必须要 一层一层往下去调用接口来实现，如果都交给 这个函数来完成的话，程序的效率就会下降。

所以，直接把要输入到 文件当中的数据，直接放到 语言缓冲区当中，交给他自己来判断当前的输入的数据当中是否 又要刷新的提示字符，在合适时机，来进行刷新。

同样，语言层面的缓冲区 和 快递公司也是一样的，如果你发一个快递，就把 这个人的快递，利用 货车，或者是 飞机之类的方式，直接送到目的地，那不得亏死。

所以，肯定是把 很多人的快递一块发送，这样才省力。

在 缓冲区当中就有这么 多种刷新的方式，但是都不是 来一个 数据比如来一个 char 类型的数据就把这个数据直接发送出去，而是都是多个数据一起发送。

我们在使用 printf（）类似的函数之时：

在C语言当中我们把这些函数称之为 -- 格式化输入输出函数。

因为 strout 本质上其实是一个文件，在文件当中只能存储字符串，所以，我们在 显示器上看到的 输出的数据了，其实就是字符串。 

 而，上述函数在输出之时，像 int a = 100 ; printf（"hello %d Linux!" , a);  当中的 "hello %d Linux!" 这个字符串是我们在 函数当中使用的 格式化输出的字符串的格式，要求在 这个字符串当中的 "%d" 这个位置，替换为 a 变量的值。

而 a 变量是 int 类型，其实就是在 "%d" 这个位置 把 a 变量的值，以字符串的形式 替换到 "%d" 这个位置。

所以，其实在 语言缓冲区当中，收到的就是 这个经过格式化的 字符串，

 所以，语言缓冲区 还有一个作用就是 ： 配合格式化输出。

像底层的 操作系统级别的缓冲区，不需要给各种不同的语言来 给这个缓冲区来指定不同的 格式化 输出的方法。

自己 语言的 格式化 为 字符串的方法，由自己的语言的缓冲区来提供和实现，操作系统级别的缓冲区只用做的是 把 上层缓冲区传入的 字符串 数据，保存到自己的缓冲区当中，然后刷新到对应文件当中。

所以，各种数据，结果各个接口，来到各个缓冲区当中之时，来的时候可能是多少多少字节的方式刷新到缓冲区当中的；而又是以 多少多少字节的方式刷新到 文件当中的。

这种方式不就像是 流水一般，有近就有出；所以，我们把这个称之为 --- 文件流。

语言缓冲区在哪？

 上述我们多次 提到了 语言缓冲区，那么这个缓冲区到底在哪呢？

在 C 当中，我们要像访问 文件，对文件内容进行修改的话，离不开 C 当中的封装的一个结构体 -- FILE。

这个 FILE 本质其实就是一个结构体，在这个结构体当中封装了 fd 文件描述符。因为 不管哪种语言，只要是想访问 文件，就必须要按照 操作系统 当中访问文件的方式来访问 -- 就是使用 fd 文件描述符 ，通过 文件描述符表 当中的映射关系来找到这个文件对象，从而对 文件进行访问。

实际上，FILE 当中封装的不只是 上述的 fd文件描述符，还有 上述所说的 语言缓冲区字段 和 维护这个缓冲区的信息。

所以，其实这个缓冲区就是在 FILE 这个结构体当中 创建 和维护的。

 所以，在打开这个文件之后，如果我们先要 利用某些函数来访问到这个文件的话，就需要找到这个  FILE，所以我们才要传入这个 FILE 的指针。

所以，如果我们现在打开的 10 个文件，那么就 创建了 FILE 文件。

每一个  像不同文件写入数据的操作，实际上就是 ，通过对应文件的 FILE 结构体当中的缓冲区当中的数据，把这个数据刷新到 对应文件当中。

 如下就是 FILE 结构体的定义（部分）：

Linux 当中是 在/usr/include/stdio.h 默认是在 这个路径下：
 

typedef struct _IO_FILE FILE; // 在/usr/include/stdio.h
//在/usr/include/libio.h

struct _IO_FILE {
    int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
//缓冲区相关
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
    char* _IO_read_ptr; /* Current read pointer */
    char* _IO_read_end; /* End of get area. */
    char* _IO_read_base; /* Start of putback+get area. */
    char* _IO_write_base; /* Start of put area. */
    char* _IO_write_ptr; /* Current put pointer. */
    char* _IO_write_end; /* End of put area. */
    char* _IO_buf_base; /* Start of reserve area. */
    char* _IO_buf_end; /* End of reserve area. */
    /* The following fields are used to support backing up and undo. */
    char* _IO_save_base; /* Pointer to start of non-current get area. */
    char* _IO_backup_base; /* Pointer to first valid character of backup area */
    char* _IO_save_end; /* Pointer to end of non-current get area. */
    struct _IO_marker* _markers;
    struct _IO_FILE* _chain;
    int _fileno; //封装的文件描述符
#if 0
    int _blksize;
#else
    int _flags2;
#endif
    _IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
    unsigned short _cur_column;
    signed char _vtable_offset;
    char _shortbuf[1];
    /* char* _save_gptr; char* _save_egptr; */
    _IO_lock_t* _lock;
#ifdef _IO_USE_OLD_IO_FILE
};

通过上述的说明，你就会知道，为什么open（）函数返回的是 FILE* ， 在 open（）函数当中肯定是要 类似 FILE* file = (FILE*)malloc(sizeof(xxx) * xxx); 这样创建一个 FILE 结构体对象的操作。

C 当中的 FILE 对象是属于用户？还是操作系统？

答案是属于 用户的，所有的语言层面的，都是属于用户的。 所以，我们 把 FILE 当中的缓冲区，称之为 用户级别的缓冲区。

理解开头 例子 （理解子进程当中继承的父进程当中的 FILE）

 所以你就可以了理解上述的例子为什么会输出上述的 结果了：
 

 因为我们上述在进行输出的时候，使用了 ">" 这个重定向符号，我们知道，在上述例子当中的这个 ">" 其实实现就是 把 输出文件从 stdout 文件改为了 log.txt 文件。

那么，缓冲区的刷新方式 也从 显示文件的 行刷新 转变到了 文件的全刷新。

也就是说此时，遇到 '\n' 不会再进行刷新。 只有当缓冲区当中的数据已经被写满了，才会去刷新。在不满的情况下，只有在 进程结束才会刷新。

现在，我们再把下述程序的输出过程来证明一下：

上述程序输出：

为什么是 wirte（）先打印？

我们写一个 简单的 脚本来查看 这个程序的运行过程，查看 写入顺序：

脚本 输出：
 

  •  而在上述代码当中，是先把三个 C库函数调用完毕，然后再调用 write（）系统调用接口；
  • 那么，程序只要是输出了 write（）函数输出的内容，说明上述的 三个 C库函数 已经 调用完毕。 那么为什么不输出  三个 C库函数 的输出结果呢？为什么是在后面 输出呢？就是因为 这个  三个 C库函数 是往 语言缓冲区当中输出的；而 write（）是直接往 系统缓冲区当中输出的。
  •  而且，在上述代码当中，三个 C库函数 输出的字符串当中都带上了 '/n' 的，按照 显示器文件，那么应该是 一个C 库函数的输出，但是为什么上述是一起输出的呢？                                                其实就是因为，当我们， 重定向之后，输出文件变成了 log.txt 这个文件，这是普通文件，所以 刷新方式是 全刷新方式。

所以，在上述例子的基础之上，我们创建了子进程，输出如下所示：
 

其实就是因为:

缓冲区的刷新方式变成了全缓冲（在不满的情况下，只有在 进程结束才会刷新），因为 write（）函数是直接往 系统缓冲区当中刷新数据，所以，可以直接刷新到文件。

在 父进程当中，write（）函数调用之前 调用的 三个 C库函数，已经被刷新到 语言缓冲区当中的，但是因为是 全刷新方式，所以，遇到 '\n'，没有刷新到 系统缓冲区当中。

当子进程当中，虽然没有调用 三个 C库函数，此时，对于 父子进程来说，他们共有一个 代码和数据，也就是此时，父子进程共有 一个 FILE 结构体对象，那么其中的缓冲区也是共有的。

但是，因为最后，当程序执行结束时，就要把缓冲区当中的数据刷新到 系统缓冲区当中；对于 父进程来说，把缓冲区当中内容刷新到 系统缓冲区当中这个操作，不就相当于是把 FILE 当中的缓冲区字段清空了，这不就是修改操作吗？

所以，在父子进程当中，不管是谁修改了某一个数据，操作系统就会为这个 进程 进行写时拷贝。所以，此时，父子进程当中就有了 两个 FILE 结构体对象，也就有了 父子进程 各自独有的缓冲区了。

也就是说，在最后 把 父子进程共有的 缓冲区当中的数据刷新到 系统缓冲区当中之时，对于父进程，缓冲区其实就是我们在堆上开辟出的空间，刷新到 系统缓冲区这个操作，就是把 这个堆上开辟空间存储的数据全部删除了，也就相当于是 父进程 对这个空间当中的数据进行了修改，所以要发生写时拷贝。

写时拷贝之后，父子进程就拥有 各自的 两个独立的 FILE 对象了，也就有两个 独立的 缓冲区了。

而，子进程当中缓冲区的数据 还是之前 三个 C库函数 写入的数据，父进程也还是，所以，我们发现，在C 库函数当中输出的内容，在创建子进程之后，打印了两遍了。

 而 上述是因为 fork（）创建了子进程，而且，还使用了 ">" 把程序输出内容输出到 文件当中，改变了刷新方式；

而，如果我们直接运行程序，不重定向到 其他普通文件，就算我们 创建了子进程，因为 显示器文件是行刷新的，在上述例子当中每一个 C库函数 当中的输出字符串 当中就有 '\n' 字符，用于 很刷新的判断。

所以，每调用完 函数，就会检测到 '\n' 字符，直接就进行刷新了。

简单模拟实现 C 当中的 fopen（）等等函数

简单模拟实现，主要是理解 C 当中封装 的 系统调用接口，是如何进行调用的，当然，这里实现肯定是没有 Linux 当中 C 库函数写的好的，主要是帮助理解：

 上述是在  Linux 当中 ，在各个 系统调用接口基础之上来实现的 ，封装的 fopen（），fwrite（）···· 这些函数，如果我们在 windows，mac 等等其他的 操作系统当中。

虽然上述的 不同操作系统当中 这些系统调用接口肯定是不一样的，但是，如果都在这些系统当中进行了封装，以 条件编译的 形式（如 #ifndef 宏），都放到C语言源代码当中，那么，不同的操作系统来调用，就可以把 这些函数裁剪成是自己操作系统调用接口的代码（库）。

实现，在不同的平台下，实现 封装的函数名相同，但是底层调用的 系统调用接口不一样。

像上述就是 适合于 Linux 当中的 代码。 

 这就叫做，C语言具有跨平台性。

就像 移植性 非常强的 java，就是用 JVM java虚拟机实现的，java 的所有平台上的代码，都在 JVM 当中进行解释，所以我们在自己的本地机器当中，像运行一个 JAVA 程序，就要 有 JVM JAVA 环境，运行 java 程序之前要启动虚拟机。

其实，本质上，底层 JVM 就是用 C/C++ 来实现的，运行 JVM 的本质就是用 C/C++ 可执行程序 运行 JVM 进程。

 在 JVM 当中，实现 移植，就是用 类似上述的方式，来切分出 代码，哪一个操作系统 应该使用哪一些 系统调用接口，切分好，就执行那一部分代码。

而且，在系统调用层面上，是不管 我们 输入输出 输入的是什么变量的，因为，不管是 我们从键盘，文件当中地区 数据到 程序当中，变量接收；还是 从程序当中 写入数据到 文件当中；在 操作系统看来， 都是字符串。

 由上图可以发现，接收的 数据是以 void* buf 变量来接受的，不管传入的是什么类型的变量，都是以 字符串的形式接受 输入和输出的。

我们之所以能用 变量去 接收字符串当中某些数据，或者是 把某些变量 当中的数据 输出到 文件当中，这些操作，是由  scanf（） 和 printf（） 这些类似的 格式化输入输出函数 来帮我们 格式化的输入输出数据的。

所以，键盘显示器这些设备，叫做 字符设备。而不叫做 整数设备什么的。

所以，就和之前所说的 FILE 当中缓冲区存在的意义就是，让我们调用 C 的库函数更快，以为调用 write（）之类的函数，比如刷新数据到 系统缓冲区当中是要花费时间的，所以，就攒一波数据，同一发送，把很多数据一起发送到 缓冲区当中，就减少了IO的次数，提高了我们调用 fwrite（）等等库函数的效率。

所以，像全缓冲，看似是，如果我们没有写满 语言缓冲区，那么就不会刷新，但是还是有其他情况可以强制刷新 语言缓冲区当中数据，比如调用 fflush（）函数，或者是 close（）关闭文件。都会刷新缓冲区。

完整代码：
 

// Mystdio.c
#include "Mystdio.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

#define FILE_MODE 0666

// "w", "a", "r"
_FILE* _fopen(const char* filename, const char* flag)
{
    // 防止用户传入参数操作
    assert(filename);
    assert(flag);

    int f = 0;
    int fd = -1; 
    // 如果是以写的方式
    if (strcmp(flag, "w") == 0) {
        // 下述是库函数当中的 三个宏 ，代表的是 open（）当中读写方式的不同参数
        f = (O_CREAT | O_WRONLY | O_TRUNC);

        // 调用 open 系统调用接口
        fd = open(filename, f, FILE_MODE);
    }
    // 如果是以追加的方式
    else if (strcmp(flag, "a") == 0) {
        f = (O_CREAT | O_WRONLY | O_APPEND);
        fd = open(filename, f, FILE_MODE);
    }
    // 如果是以读的方式
    else if (strcmp(flag, "r") == 0) {
        f = O_RDONLY;
        fd = open(filename, f);
    }
    // 如果上述都不是，就返回 NULL指针，说明打开文件失败
    else
        return NULL;

    // 同样，如果 open（）函数返回 -1 ，说明 open（）函数打开文件失败。返回 NULL
    if (fd == -1) return NULL;

    // 这个是文件对象（注意：此处是 相当于是 C 当中的 FILE）
    _FILE* fp = (_FILE*)malloc(sizeof(_FILE));
    if (fp == NULL) return NULL;  // 防止 malloc 失败

    // 给 FILE当中的 成员赋值
    fp->fileno = fd;   // 文件描述符
    //fp->flag = FLUSH_LINE;
    fp->flag = FLUSH_ALL;  // 默认是 全缓冲的方式
    fp->out_pos = 0;       // 初始，FILE 当中的缓冲区是没有数据的

    return fp;
}

// FILE中的缓冲区的意义是什么？？？？
int _fwrite(_FILE* fp, const char* s, int len)
{
    // "abcd\n"
    // 把 
    memcpy(&fp->outbuffer[fp->out_pos], s, len); // 没有做异常处理, 也不考虑局部问题
    fp->out_pos += len;

    // 如果是 无缓冲
    if (fp->flag & FLUSH_NOW)
    {
        // 直接调用 wirte（）系统调用接口进行刷新
        write(fp->fileno, fp->outbuffer, fp->out_pos);
        fp->out_pos = 0;   // 刷新之后，FILE 当中的缓冲区不再有数据
    }
    // 如果是 行缓冲
    else if (fp->flag & FLUSH_LINE)
    {
        // 如果字符串末尾是  '\n'，不考虑中间有 '\n'，或者是 多个  '\n' 的情况
        // 简单实现
        if (fp->outbuffer[fp->out_pos - 1] == '\n') { // 不考虑其他情况
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;// 刷新之后，FILE 当中的缓冲区不再有数据
        }
    }
    // 如果是 全缓冲
    else if (fp->flag & FLUSH_ALL)
    {
        // SIZE 是定义的宏，当前默认是 1024
        if (fp->out_pos == SIZE) {
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;// 刷新之后，FILE 当中的缓冲区不再有数据
        }
    }

    return len;
}

// 封装 fflush（）函数，作用是刷新缓冲区
void _fflush(_FILE* fp)
{
    if (fp->out_pos > 0) {
        write(fp->fileno, fp->outbuffer, fp->out_pos);
        fp->out_pos = 0;
    }
}

void _fclose(_FILE* fp)
{
    // 特殊处理
    if (fp == NULL) return;
    _fflush(fp);  // 如果 当前缓冲区当中还有数据，就刷新缓冲区
    close(fp->fileno);   // 调用close 系统调用接口
    free(fp);            // 释放 FILE 结构体对象
}

//Mystdio.h
#ifndef __MYSTDIO_H__
#define __MYSTDIO_H__

#include <string.h>

#define SIZE 1024

#define FLUSH_NOW 1
#define FLUSH_LINE 2
#define FLUSH_ALL 4

typedef struct IO_FILE {
    int fileno;           // 封装 fd 文件描述符
    int flag;             //
    //char inbuffer[SIZE];
    //int in_pos;
    char outbuffer[SIZE]; // 缓冲区字段
    int out_pos;          // 维护缓冲区大小
}_FILE;

_FILE* _fopen(const char* filename, const char* flag);
int _fwrite(_FILE* fp, const char* s, int len);
void _fclose(_FILE* fp);


#endif


//main.c
#include "Mystdio.h"
#include <unistd.h>

#define myfile "test.txt"

int main()
{
    _FILE* fp = _fopen(myfile, "a");
    if (fp == NULL) return 1;

    const char* msg = "hello world\n";
    int cnt = 10;
    while (cnt) {
        _fwrite(fp, msg, strlen(msg));
        // fflush(fp);
        sleep(1);
        cnt--;
    }

    _fclose(fp);

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/156606.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

C# 实时监控双门双向门禁控制板源码

C# 实时监控双门双向门禁控制板源码

本示例使用设备&#xff1a;实时网络双门双向门禁控制板可二次编程控制网络继电器远程开关-淘宝网 (taobao.com) using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.…
阅读更多...
数据库实验报告（六）

数据库实验报告（六）

实验报告&#xff08;六&#xff09; 1、实验目的 &#xff08;1&#xff09; 掌握关联查询的用法 &#xff08;2&#xff09; 掌握集合查询的区别和用法 &#xff08;3&#xff09; 掌握EXISTS的用法 2、实验预习与准备 &#xff08;1&#xff09; 了解ANY&…
阅读更多...
在docker中部署MySQL

在docker中部署MySQL

目录 1、拉取最新的镜像 2、创建mysql容器实例 3、启动mysql实例 4、进入mysql 交互环境 5、登录MySQL数据库 6、尽情享用mysql 1、拉取最新的镜像 docker image pull mysql 2、创建mysql容器实例 第一次执行&#xff0c;需要先创建容器并启动&#xff08;容器名是mys…
阅读更多...
分享一个自用的Win11护眼主题（无需下载）

分享一个自用的Win11护眼主题（无需下载）

先放上几张效果图 设置方法 首先&#xff0c;把主题设置为高对比度主题——沙漠。 然后点击编辑&#xff0c;依次设置为以下值 背景&#xff1a;#1C5E75文本&#xff1a;#FFF5E3超链接&#xff1a;#6EFFA4非活动文本&#xff1a;#FFF5E3选定文本&#xff1a;#903909、#8EE3F0…
阅读更多...
巾帼调查队开展实务调查技能，促全职妈妈联增收

巾帼调查队开展实务调查技能，促全职妈妈联增收

2024年11月14日上午&#xff0c;由罗湖区妇联主办、罗湖区懿米阳光公益发展中心承办的“巾帼调查队—社区女性增值计划”项目第三期活动在罗湖区妇儿大厦六楼成功举办&#xff0c;30名阳光妈妈及全职妈妈参与了此次调查实务技巧培训。 在培训开始之前&#xff0c;巾帼调查队的创…
阅读更多...
深度探讨丨关于工作量证明的常见误解

深度探讨丨关于工作量证明的常见误解

有一种基本误解认为&#xff0c;工作量证明机制在本质上是不可扩展的&#xff0c;并且会产生过度的能源耗费。 按照工作量证明区块链的最初设计&#xff0c;以及BSV区块链协会的推广&#xff0c;这一技术旨在实现可扩容性&#xff0c;同时确保高效能系统内的安全性和互操作性。…
阅读更多...
基于IDEA进行Maven工程构建

基于IDEA进行Maven工程构建

Java全能学习面试指南&#xff1a;https://javaxiaobear.cn 1. 构建概念和构建过程 项目构建是指将源代码、依赖库和资源文件等转换成可执行或可部署的应用程序的过程&#xff0c;在这个过程中包括编译源代码、链接依赖库、打包和部署等多个步骤。 项目构建是软件开发过程中…
阅读更多...
【智能家居】5、主流程设计以及外设框架编写

【智能家居】5、主流程设计以及外设框架编写

一、主流程设计 #include <stdio.h>int main(){//指令工厂初始化//控制外设工厂初始化//线程池return 0; } 1、工厂模式结构体定义 &#xff08;1&#xff09;指令工厂 inputCmd.h struct InputCmd{char cmdName[128];//指令名称char cmd[32];//指令int (*Init)(char …
阅读更多...
解决margin-top导致的塌陷

解决margin-top导致的塌陷

什么是margin-top塌陷 若要使子元素距离父元素顶部有一定距离&#xff0c;如果只给子元素设置margin-top属性&#xff0c;结果发现父元素顶部出现位移&#xff0c;子元素相对父元素没位移&#xff0c;这就是margin-top导致的塌陷。 .fatherplus{width: 600px;height: 600px;b…
阅读更多...
筋膜炎怎么治疗才能除根

筋膜炎怎么治疗才能除根

筋膜炎的引起原因&#xff0c;常见的有以下几种&#xff1a; 1.职业因素。经常牵拉某些肌肉容易导致肌肉出现劳损&#xff0c;如司机、教师、运动员等&#xff0c;发生筋膜炎的几率会明显比正常人要高。 2.疾病因素。例如扁平足、糖尿病的人群&#xff0c;发生足底筋膜炎的几…
阅读更多...
为了 Vue 组件测试，你需要为每个事件绑定的方法加上括号吗？

为了 Vue 组件测试，你需要为每个事件绑定的方法加上括号吗？

本文由华为云体验技术团队松塔同学分享 先说结论&#xff0c;当然不是&#xff01;Vue 组件测试&#xff0c;尤其是组件触发事件的测试&#xff0c;有成熟的示例。我们同样要关注测试的原则&#xff0c;例如将组件当成黑盒&#xff0c;不关心其内部实现&#xff0c;而只关心与其…
阅读更多...
java集合,栈

java集合,栈

只有栈是类 列表是个接口 栈是个类 队列 接口有双链表,优先队列(堆) add会报错 offer是一个满了不会报错 set集合 有两个类实现了这个接口
阅读更多...
剑指Offer || 105.岛屿的最大面积

剑指Offer || 105.岛屿的最大面积

题目 给定一个由 0 和 1 组成的非空二维数组 grid &#xff0c;用来表示海洋岛屿地图。 一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合&#xff0c;这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0&#xff08;代表水&#x…
阅读更多...
div中一个div怎么在高度上居中,小div在大div的高度的中间

div中一个div怎么在高度上居中,小div在大div的高度的中间

实现效果: 让这个去分享在高度上的居中 答案: 直接设置 margin:auto;
阅读更多...
Draco Win10编译

Draco Win10编译

1. 工具 CMake 3.2.8&#xff0c;Visual Studio 2019 2. 步骤 2.1 拷贝代码 git clone https://github.com/google/draco.gitgit clone https://github.com/google/draco.git 下载第三方依赖 git submodule sync git submodule update --init --recursive 2.2 CMake编译…
阅读更多...
Linux Shell脚本的10个有用的“面试问题和解答”

Linux Shell脚本的10个有用的“面试问题和解答”

Shell 是什么&#xff1f; 在 Linux 中&#xff0c;Shell 是一个应用程序 &#xff0c;它是用户与 Linux 内核沟通的桥梁。 它负责接收用户输入的命令&#xff0c;根据用户的输入找到其他程序并运行&#xff0c;Shell负责将应用层或者用户输入的命令传递给系统内核&#xff0…
阅读更多...
《全程软件测试 第三版》拆书笔记

《全程软件测试 第三版》拆书笔记

第一章 对软件测试的全面认识&#xff0c;测试不能是穷尽的 软件测试的作用&#xff1a; 1.产品质量评估&#xff1b;2.持续质量反馈&#xff1b;3.客户满意度提升&#xff1b;4.缺陷的预防 正反思维&#xff1a;正向思维&#xff08;广度&#xff0c;良好覆盖面&#xff09;逆…
阅读更多...
利用IP地址查询优化保险理赔与业务风控的实用方法

利用IP地址查询优化保险理赔与业务风控的实用方法

随着数字化时代的到来&#xff0c;保险行业正逐渐采用先进的技术来改善理赔流程和强化业务风控。其中&#xff0c;通过IP地址查询成为一种有效的手段&#xff0c;为保险公司提供更精准的信息&#xff0c;以便更好地管理风险和提高服务效率。本文将探讨如何利用IP地址查询优化保…
阅读更多...
AD教程 （十七）3D模型的创建和导入

AD教程 （十七）3D模型的创建和导入

AD教程 &#xff08;十七&#xff09;3D模型的创建和导入 对于设计者来讲&#xff0c;现在3DPCB比较流行&#xff0c;3DPCB&#xff0c;除了美观之外&#xff0c;做3D的最终的一个目的&#xff0c;是为了去核对结构&#xff0c;就是我们去做了这么一个PCB之后&#xff0c;如果说…
阅读更多...
外汇天眼：什么是非农？非农数据对外汇市场的重要性！

外汇天眼：什么是非农？非农数据对外汇市场的重要性！

非农数据在外汇市场中扮演着何等关键的角色&#xff1f; 美国非农数据&#xff0c;简称“非农”&#xff0c;具体指排除农业部门、个体户和非盈利机构雇员后的就业相关数据&#xff0c;是反映美国经济实际就业和整体经济状况的关键指标。该数据由美国劳工部劳动统计局每月发布…
阅读更多...
最新文章

Copyright @ 2022~2023