Linux 文件操作核心：缓冲区机制与文件描述符原理

前 6 秒时 C 接口的函数被存储在 C 语言的缓冲区中，write 函数通过缓冲区直接写入文件中，当进程结束时刷新缓冲区将数据放入文件中。文件刷新为全缓冲，\n 不会刷新缓冲区，而是等缓冲区写满才会被刷新。

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(){
    const char* fstr = "hello fwrite\n";
    const char* str = "hello write\n";
    //Cprintf("hello printf\n");
    //stdout ---> 1
    fprintf(stdout, "hello fprintf\n");
    //stdout ---> 1
    fwrite(fstr, strlen(fstr), 1, stdout);
    //stdout ---> 1
    close(1);
    //操作系统提供的系统接口
    write(1, str, strlen(str));
    //stdout ---> 1
    fork();
    return 0;
}

和第 1 次代码的结果不同，添加 close 后，C 语言的接口输出了 1 次，系统调用的接口没有输出。

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(){
    const char* fstr = "hello fwrite";
    printf("hello printf");
    //stdout ---> 1
    fprintf(stdout, "hello fprintf");
    //stdout ---> 1
    fwrite(fstr, strlen(fstr), 1, stdout);
    //stdout ---> 1
    close(1);
    return 0;
}

如果去掉 \n，代码没有输出。

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(){
    const char* str = "hello fwrite";
    write(1, str, strlen(str));
    //stdout ---> 1
    close(1);
    return 0;
}

代码没有 \n，和 C 语言的接口不同，系统调用的接口可以输出。

总结

1. 缓冲区一定不在操作系统内部，不是系统级别的缓冲区。write 可以输出是因为 write 直接将字符串写入了缓冲区中，close 对显示没有影响。
2. C 语言会提供一个用户级缓冲区，C 语言的接口函数传递的数据实际上储存在 C 语言提供的用户级缓存区中，当调用 \n、fclose 等可以刷新缓冲区时，才会刷新 C 语言提供的缓冲区，并调用 write 函数，将数据写入操作系统中。
3. C 语言的文件操作绕不开 FILE，FILE 中包含文件描述符 fd，FILE 里面还有对应打开文件的缓冲区字段。这个 FILE 对象属于用户，语言都属于用户层。
4. 显示器的文件刷新方案是行刷新，所以在 printf 执行完成后就会立即遇到 \n 的时候，将数据进行刷新。刷新的本质是将数据通过 1 + write 通过 write 接口写入到内核中。

目前我们认为，只要将数据刷新进入了内核中，数据就会被刷新进入硬件中。

2、exit 和 _exit

exit 是 C 语言的接口，退出时会刷新 C 语言提供的缓冲区，然后调用 _exit 退出，_exit 是系统调用，直接释放进程不会对数据进行刷新。

3、缓冲区的刷新问题

操作系统会维护缓冲区。

（1）无缓冲

无缓冲区是一种写透模式，不要在缓冲区中做出各种数据残留，直接刷新，不能等待，没有进行各种刷新策略。

（2）行缓冲

不刷新直到遇到 \n 才会刷新。默认向显示器输出采用行刷新是因为显示器是给人看的，人每次看数据符合每次看一行的习惯，需要尽可能快的把数据刷新出来。

（3）全缓冲

缓冲区满了才会刷新缓冲区。在向普通文件写入时为了提高效率刷新时不需要实时观看所以采用全缓冲。

根据这 3 种情况来决定什么时候调用 write 接口的问题。fflush 的底层会封装 write。缓冲区中存储的数据越多，效率越高。

4、进程退出

进程退出时也会刷新缓冲区。

示例 1

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(){
    printf("hello world");
    return 0;
}

示例 2

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(){
    printf("hello world");
    close(1);
    return 0;
}

printf("hello world");若未包含换行符 \n 且程序未结束或未手动刷新，数据会暂时留在缓冲区中，不会立即显示在终端上。当使用 close(1) 后，文件描述符被关掉，会导致缓冲区中的数据未来得及刷新就丢失，最终无法在显示器上显示。

5、C 语言提供缓冲区的原因

1. 解决效率问题，硬件设备的读写速度远慢于 CPU 和内存的处理速度。缓冲区用于临时存储待输出或待读取的数据。程序先将数据写入缓冲区，待缓冲区满、触发特定条件或程序结束时，再一次性将缓冲区数据写入硬件设备。这大幅减少了硬件 I/O 的次数，从而提升整体效率。
2. 标准 I/O 库通过缓冲区批量处理数据，将多次小的 I/O 请求合并为一次大的请求，从而减少系统调用的次数，降低开销。
3. 优化用户交互体验。数据暂存在缓冲区，直到遇到换行符 \n 才刷新到屏幕。这种设计符合人类阅读习惯，用户更希望看到完整的一行内容，而非字符逐个零散显示。

二、模拟实现 C 文件标准库

1、为什么要'造轮子'？

我们平时写 C 语言文件操作时，习惯直接调用标准库的 fopen、fwrite、fclose - - - 这些函数好用，但你有没有想过：

1. 为什么 fwrite 不是'写了就立刻到文件'？
2. FILE 结构体里到底存了什么？
3. 标准库是怎么跟操作系统交互的？

这是一个简化版的 C 文件操作库：手动实现了 _fopen、_fwrite、_fflush、_fclose，没有依赖标准库的 stdio.h，而是直接调用操作系统的底层接口（open、write、close），还加入了核心的缓冲区机制。FILE 中的缓冲区的意义是使用 C 语言的接口更快，节省时间。

2、核心原理

在拆解代码前，先搞懂 3 个核心概念：系统调用、缓冲区、刷新策略 - - - 这是所有高级语言文件操作的'通用逻辑'。

（1）系统调用与用户层封装

Linux 操作系统提供了最底层的文件操作接口，称为系统调用（如 open、write、close）。但系统调用的'开销很高' - - - 每次调用都要从用户态切换到内核态，频繁调用会拖慢程序。

C 标准库的 stdio 系列函数（fopen、fwrite）本质上是对系统调用的封装，核心目的是：在用户层加一层'缓冲区'，减少系统调用的次数，从而提高 IO 效率。

我们的代码也遵循这个逻辑：

1. 用 _FILE 结构体封装文件描述符（fileno）和缓冲区；
2. _fopen 封装 open 系统调用；
3. _fwrite 先写缓冲区，满了再调用 write；
4. _fclose 先刷新缓冲区，再调用 close。

（2）缓冲区

为什么缓冲区能提高效率？ 举个例子： 如果要写 1000 个字符到文件，直接调用 write 需要 1000 次系统调用；但如果先把字符存到 1024 字节的缓冲区，满了再调用 1 次 write，系统调用次数从 1000 降到 1 - - - 效率天差地别。 代码里，缓冲区通过 FILE 结构体的 outbuffer（字符数组）和 out_pos（当前缓冲区已用长度）实现，缓冲区大小由 SIZE 宏定义为 1024 字节。

（3）缓冲刷新的 3 种策略

缓冲区的数据不会一直存着，需要在特定时机'刷新'到磁盘，代码里定义了 3 种刷新策略（通过 flag 控制）：

FLUSH_NOW：无缓冲，写入后立即刷新 FLUSH_LINE：行缓冲，遇到 \n 时刷新 FLUSH_ALL：全缓冲，缓冲区满了才刷新。

3、代码拆解

接下来逐文件解析代码，搞懂每个函数的核心逻辑。

（1）头文件 myfile.h

头文件的作用是'对外声明' - - - 定义结构体、宏、函数接口，让其他文件能复用。

#ifndef __MYFILE_H__ // 防止头文件重复包含（比#pragma once 更通用）
#define __MYFILE_H__
// 引入依赖的系统头文件
#include<stdlib.h>// malloc/free
#include<string.h>// memcpy/strcmp
#include<sys/types.h>
#include<sys/stat.h>// 文件状态相关
#include<fcntl.h>// open 系统调用的标志（O_CREAT、O_WRONLY 等）
#include<assert.h>// 断言（调试用）
#include<unistd.h>// close/write/sleep 系统调用

// 1. 宏定义：缓冲区大小 + 刷新策略
#define SIZE 1024 // 输出缓冲区大小：1024 字节
#define FLUSH_NOW 1 // 立即刷新（无缓冲）
#define FLUSH_LINE 2 // 行刷新（遇\n 刷）
#define FLUSH_ALL 4 // 全缓冲（满了刷）

// 2. 自定义文件结构体：替代标准库的 FILE
typedef struct IO_FILE{
    int fileno; // 文件描述符（操作系统给文件的唯一标识）
    int flag; // 缓冲刷新策略（FLUSH_NOW/FLUSH_LINE/FLUSH_ALL）
    // int in_pos; // （未实现）输入缓冲区当前位置
    // char inbuffer[SIZE]; // （未实现）输入缓冲区
    char outbuffer[SIZE]; // 输出缓冲区：存待写入文件的数据
    int out_pos; // 输出缓冲区当前已用长度（从 0 开始）
}_FILE;

// 重命名为_FILE，简化使用

// 3. 函数声明：对外提供的文件操作接口
_FILE*_fopen(const char* filename, const char* flag); // 打开文件
int _fwrite(_FILE* fp, const char* msg, int len); // 写入数据
void_fclose(_FILE* fp); // 关闭文件
void_fflush(_FILE* fp); // 强制刷新缓冲区
#endif

关键点：

1. 用 #ifndef MYFILE_H 防止头文件被重复包含（比如 main.c 和 myfile.c 都包含 myfile.h，编译时不会报错）。
2. _FILE 结构体只实现了输出缓冲区，输入缓冲区（inbuffer/in_pos）被注释了。
3. fileno 是核心：操作系统通过文件描述符识别文件，所有底层操作都依赖它。

（2）文件 myfile.c

myfile.c 负责把 myfile.h 声明的接口落地，核心是 4 个函数：_fopen、_fwrite、_fflush、_fclose。

1. _fopen

_fopen 的作用是 根据用户传入的'打开模式'（flag），调用 open 系统调用创建文件描述符，再分配并初始化 _FILE 结构体。

#include"myfile.h"
#define FILE_MODE 0666 // 文件创建时的权限（可读可写，所有者/组/其他用户）

_FILE*_fopen(const char* filename, const char* flag){
    assert(filename); // 调试断言：如果 filename 为 NULL，直接崩溃（避免非法访问）
    int open_flags = 0; // 传给 open 系统调用的标志
    int fd = -1; // 文件描述符（初始化为 -1，代表无效）

    // 1. 根据打开模式（flag）设置 open 的标志
    if(strcmp(flag,"w")==0) // 写模式：创建文件（不存在则建）、只写、覆盖原有内容
    {
        open_flags = O_CREAT|O_WRONLY|O_TRUNC; // O_CREAT：文件不存在则创建；O_WRONLY：只写；O_TRUNC：清空原有内容
        fd = open(filename, open_flags, FILE_MODE); // 创建文件时需指定权限
    }
    else if(strcmp(flag,"a")==0) // 追加模式：创建文件、只写、在文件末尾追加
    {
        open_flags = O_CREAT|O_WRONLY|O_APPEND; // O_APPEND：每次写都追加到文件末尾
        fd = open(filename, open_flags, FILE_MODE);
    }
    else if(strcmp(flag,"r")==0) // 读模式：只读（文件必须存在）
    {
        open_flags = O_RDONLY;
        fd = open(filename, open_flags); // 读模式不需要权限参数
    }
    else{return NULL; // 不支持的模式，返回 NULL
    }

    // 2. 检查 open 是否成功（fd == -1 代表失败，比如文件不存在、权限不够）
    if(fd == -1){return NULL;}

    // 3. 分配_FILE 结构体内存（用户层的文件对象）
    _FILE* fp = (_FILE*)malloc(sizeof(_FILE));
    if(fp == NULL) // 检查内存是否分配成功（避免内存不足导致崩溃）
    {
        return NULL;
    }

    // 4. 初始化_FILE 结构体
    fp->fileno = fd; // 绑定文件描述符
    fp->flag = FLUSH_ALL; // 默认使用'全缓冲'策略
    fp->out_pos = 0; // 输出缓冲区初始为空（已用长度为 0）
    return fp; // 返回用户层的文件指针
}

关键点：

1. FILE_MODE 0666：文件权限的八进制表示，rw-rw-rw-（所有者、组、其他用户都有读写权限），但实际权限会受 umask 影响（比如默认 umask 0022，实际权限会变成 0644）；
2. open 的标志组合：不同模式对应不同的标志，比如 w 模式必须加 O_TRUNC（清空文件），a 模式必须加 O_APPEND（追加）；
3. 内存分配检查：malloc 可能失败（比如内存不足），必须检查 fp == NULL，否则后续操作会崩溃。

2. _fwrite

_fwrite：不直接写文件，而是先把数据拷贝到缓冲区，再根据 flag 判断是否需要刷新到磁盘。

int _fwrite(_FILE* fp, const char* s, int len){
    // 1. 把数据拷贝到输出缓冲区（当前代码未处理缓冲区溢出！）
    memcpy(&fp->outbuffer[fp->out_pos], s, len);
    fp->out_pos += len; // 更新缓冲区已用长度

    // 2. 根据刷新策略，判断是否需要调用 write 刷新到文件
    if(fp->flag & FLUSH_NOW) // 立即刷新：不管缓冲区是否满，直接写
    {
        write(fp->fileno, fp->outbuffer, fp->out_pos);
        fp->out_pos = 0; // 刷新后，缓冲区重置为空
    }
    else if(fp->flag & FLUSH_LINE) // 行刷新：遇到\n 才刷新
    {
        if(fp->outbuffer[fp->out_pos -1]=='\n') // 检查最后一个字符是否是\n
        {
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;
        }
    }
    else if(fp->flag & FLUSH_ALL) // 全缓冲：缓冲区满了才刷新
    {
        if(fp->out_pos == SIZE) // 已用长度等于缓冲区大小，满了
        {
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;
        }
    }
    return len; // 返回写入的字节数（简化处理，未检查实际写入量）
}

关键点：

1. 缓冲区溢出风险：当前代码直接 memcpy，如果 fp->out_pos + len > SIZE（比如剩余缓冲区只有 50 字节，要写 100 字节），会导致数据溢出 outbuffer，破坏内存 - - - 这是严重 bug，后续优化会解决。
2. 刷新策略的实际效果：当前 _fopen 默认用 FLUSH_ALL，即使写入的字符串有 \n，也不会立即刷新，只会在缓冲区满（1024 字节）或 _fclose 时刷新。

3. _fflush

_fflush 的作用是'不管缓冲区是否满、是否有 \n'，强制把缓冲区的数据写到文件，常用于 fclose 前或需要立即落盘的场景。

void_fflush(_FILE* fp){
    if(fp->out_pos > 0) // 只有缓冲区有数据时才刷新
    {
        write(fp->fileno, fp->outbuffer, fp->out_pos);
        fp->out_pos = 0; // 重置缓冲区
    }
}

判断缓冲区是否有数据（out_pos > 0），有就调用 write，然后重置 out_pos。

4. _fclose

_fclose 是'收尾工作'：必须先刷新缓冲区（避免数据残留），再关闭文件描述符，最后释放 _FILE 结构体的内存。

void_fclose(_FILE* fp){
    assert(fp); // 断言：fp 不能为 NULL（避免非法访问）
    _fflush(fp); // 1. 先强制刷新缓冲区（关键！否则缓冲区数据会丢失）
    close(fp->fileno); // 2. 关闭文件描述符（归还操作系统资源）
    free(fp); // 3. 释放_FILE 结构体内存（避免内存泄漏）
}

核心原则：

1. 必须先刷新再关闭：如果不调用 _fflush，缓冲区中未刷的数据会随着 fp 被 free 而丢失。
2. 资源释放顺序：先释放用户层资源（缓冲区数据），再释放内核层资源（文件描述符），最后释放内存。

4、运行与验证

观察结果

代码运行多次，会继续追加内容（因为打开模式是 a）。

编译并运行代码

5、完整代码展示

myfile.c

#include"myfile.h"
#define FILE_MODE 0666 //"w" "a" "r"

_FILE*_fopen(const char* filename, const char* flag){
    assert(filename);
    int f = 0;
    int fd = -1;
    if(strcmp(flag,"w")==0){
        f =(O_CREAT|O_WRONLY|O_TRUNC);
        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);
    }
    else{return NULL;}
    if(fd == -1){return NULL;}
    _FILE* fp = (_FILE*)malloc(sizeof(_FILE));
    if(fp == NULL){return NULL;}
    fp->fileno = fd;
    fp->flag = FLUSH_ALL;
    fp->out_pos = 0;
    return fp;
}

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){
        write(fp->fileno,fp->outbuffer,fp->out_pos);
        fp->out_pos = 0;
    }
    else if(fp->flag & FLUSH_LINE){
        if(fp->outbuffer[fp->out_pos-1]=='\n'){
            write(fp->fileno,fp->outbuffer,fp->out_pos);
            fp->out_pos = 0;
        }
    }
    else if(fp->flag & FLUSH_ALL){
        if(fp->out_pos == SIZE){
            write(fp->fileno,fp->outbuffer,fp->out_pos);
            fp->out_pos = 0;
        }
    }
    return len;
}

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){
    assert(fp); // 进程结束时，缓冲区有内容直接刷新
    _fflush(fp);
    close(fp->fileno);
    free(fp);
}

myfile.h

// 防止文件被重复包含
//#pragma once

#ifndef __MYFILE_H__
#define __MYFILE_H__
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<assert.h>
#include<unistd.h>

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

typedef struct IO_FILE{
    int fileno;
    int flag;
    //int in_pos;
    //char inbuffer[SIZE];
    char outbuffer[SIZE];
    int out_pos;
}_FILE;

_FILE*_fopen(const char* filename, const char* flag);
int _fwrite(_FILE* fp, const char* msg, int len);
void_fclose(_FILE* fp);
void_fflush(_FILE* fp);

#endif

main.c

#include "myfile.h"
#define filename "test.txt"

int main(){
    _FILE* fp = _fopen(filename,"a");
    if(fp == NULL){return 1;}
    const char* msg = "hello world\n";
    int cnt = 10;
    while(cnt){
        _fwrite(fp,msg,strlen(msg));
        sleep(1);
        cnt--;
    }
    _fclose(fp);
    return 0;
}

makefile

main:main.c myfile.c
gcc -o $@ $^-std=c99
.PHONY:clean
rm -f main

三、总结

当你跑通模拟 C 库的代码，那些文件操作的困惑早已有了答案：printf 等 \n、fwrite 藏缓冲、close (1) 丢数据，本质都是'用户层与内核层交互逻辑'的体现。Linux 学习从不是记接口，而是抓本质：想清'数据在哪个缓冲'，'通过哪个描述符到内核'，多数问题会迎刃而解。继续打磨代码、追问底层，'懂原理'的每一步，都会让后续进阶更扎实。