【Linux】文件篇(五):手撕简易 FILE——模拟实现 C 标准 I/O 缓冲机制

一、为什么要自己实现一个 FILE?

前面我们已经学习了两套文件操作接口:

  • Linux 系统调用:open()、read()、write()、close()
  • C 标准 I/O:fopen()、fread()、fwrite()、fclose()

它们之间有一个重要区别:

系统调用直接面向文件描述符,而 C 标准 I/O 在文件描述符之上又封装了一层用户态缓冲区。

例如:

c 复制代码
FILE* fp = fopen("log.txt", "w");

fwrite("hello", 1, 5, fp);
fwrite("world", 1, 5, fp);

fclose(fp);

我们调用了两次 fwrite(),但不代表底层一定执行了两次 write()。

因为 C 标准 I/O 可以先把数据暂存在用户态缓冲区中,等到缓冲区满了、主动刷新,或者关闭文件时,再通过系统调用将数据提交给内核。

这就引出了一个问题:

如果让我们自己实现一个简易的 FILE,应该怎么设计?

这篇博客就从这个问题出发,手动实现一个简化版的 MyFILE。

注意:本文实现的是一个用于理解缓冲机制的教学版本,只模拟基本的写入、刷新和关闭操作,并不打算完整替代 C 标准库中的 FILE。


二、先回顾 FILE 的整体结构

在前面的学习中,我们已经知道:

FILE* 并不是文件描述符本身,而是 C 标准 I/O 库管理的一个流对象。

在常见的 Linux C 库实现中,它内部会关联一个文件描述符,同时还需要维护用户态缓冲区、缓冲区使用情况以及流的状态等信息。

可以先画出这样一张关系图:

text 复制代码
             C 语言程序
                 |
                 |
             FILE*
                 |
        +--------+--------+
        |                 |
    文件描述符 fd       用户态缓冲区
        |                 |
        |              暂存数据
        |                 |
        +--------+--------+
                 |
          文件描述符表
                 |
             struct file
                 |
             VFS 层
                 |
             文件系统
                 |
              磁盘

这里需要区分两个东西:

  • 文件描述符 fd:进程文件描述符表中的一个整数索引。
  • 用户态缓冲区:由 C 标准 I/O 库管理的一块内存,用来暂存读写数据。

当我们调用 fwrite() 时,数据可以先进入用户态缓冲区 ,而不是立即通过 write() 进入内核。

当缓冲区需要刷新时,才会调用底层的 write()。

所以,我们自己实现 MyFILE,本质上就是自己管理这两个东西:

  1. 一个文件描述符,负责连接内核中的文件对象。
  2. 一块用户态缓冲区,负责暂存程序准备写入的数据。

三、设计 MyFILE 结构体

先不急着写函数。

我们应该先思考:一个简易的文件流对象,至少需要保存哪些信息?

根据上面的分析,首先需要文件描述符和缓冲区。

另外,我们还需要知道缓冲区中已经存放了多少数据。

因此可以设计:

c 复制代码
#define BUFFER_SIZE 1024

typedef struct MyFILE
{
    int fd;                     // 文件描述符
    char buffer[BUFFER_SIZE];   // 用户态缓冲区
    size_t pos;                 // 当前缓冲区中已有的数据量
} MyFILE;

分别解释这三个成员。

1. fd:文件描述符

c 复制代码
int fd;

我们最终还是要通过 Linux 系统调用 write() 把数据写入文件。

而 write() 的第一个参数就是文件描述符:

c 复制代码
write(fd, buffer, count);

所以,MyFILE 必须保存对应的文件描述符。

2. buffer:用户态缓冲区

c 复制代码
char buffer[BUFFER_SIZE];

这块空间由我们自己定义和管理。

当程序调用 my_fwrite() 时,数据先被复制到这里。

只有当缓冲区需要刷新时,才调用 write()。

例如,假设缓冲区大小是 10 字节:

text 复制代码
buffer:

+---+---+---+---+---+---+---+---+---+---+
| h | e | l | l | o |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
                    ↑
                   pos = 5

此时缓冲区中已经有 5 个有效字节。

3. pos:记录缓冲区中已有的数据量

c 复制代码
size_t pos;

pos 是整个结构体中非常重要的成员。

它表示:

当前缓冲区中已经存放了多少个有效字节。

例如:

text 复制代码
buffer 容量:1024 字节
pos:300

说明前 300 个字节是有效数据,剩余空间还可以继续写入:

text 复制代码
+--------------------------------------+
| 已使用 300 字节 | 剩余 724 字节         |
+--------------------------------------+
                  ↑
                 pos

注意:这里的 pos 不是文件偏移量,而是缓冲区中已经使用的空间大小。

文件偏移量由底层打开文件对象管理,两者不能混淆。


四、实现 my_fopen():创建自己的文件流

有了结构体,接下来需要实现打开文件的函数。

标准 C 库提供:

c 复制代码
FILE* fopen(const char* filename, const char* mode);

我们实现一个简化版本:

c 复制代码
MyFILE* my_fopen(const char* filename);

为了控制实现难度,这里只支持 "w" 模式,也就是创建文件或者清空已有文件。

实现步骤:

  1. 调用 open() 打开文件。
  2. 使用 malloc() 申请 MyFILE 结构体空间。
  3. 初始化文件描述符和缓冲区使用量。
  4. 返回结构体指针。

代码:

c 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#define BUFFER_SIZE 1024

typedef struct MyFILE
{
    int fd;
    char buffer[BUFFER_SIZE];
    size_t pos;
} MyFILE;

MyFILE* my_fopen(const char* filename)
{
    int fd = open(filename,
                  O_WRONLY | O_CREAT | O_TRUNC,
                  0666);

    if (fd == -1)
    {
        return NULL;
    }

    MyFILE* fp = (MyFILE*)malloc(sizeof(MyFILE));

    if (fp == NULL)
    {
        int saved_errno = errno;
        close(fd);
        errno = saved_errno;
        return NULL;
    }

    fp->fd = fd;
    fp->pos = 0;

    return fp;
}

这里有两个值得注意的地方。

第一,为什么使用 O_TRUNC?

因为我们模拟的是 "w" 模式。

如果文件已经存在,打开时需要清空原有内容。

第二,为什么要判断 malloc() 是否成功?

因为打开文件和申请结构体是两个独立的操作。

如果文件已经成功打开,但结构体申请失败,就必须关闭刚刚打开的文件描述符,避免资源泄漏。

到这里,我们就拥有了一个简易的文件流对象。

五、实现 my_fflush():把缓冲区的数据写入内核

这是整个实现中最重要的函数。

我们先回忆一下缓冲区的作用:

text 复制代码
程序调用 my_fwrite()
          |
          v
    数据进入 buffer
          |
          v
     缓冲区逐渐填满
          |
          v
    调用 my_fflush()
          |
          v
       write()
          |
          v
      内核文件对象

那么 my_fflush() 应该做什么?

很简单:

把缓冲区中已经暂存的数据,通过 write() 写入文件。

函数原型:

c 复制代码
int my_fflush(MyFILE* fp);

但是这里有一个容易忽略的问题:

write() 并不保证每次都能一次性写入我们要求的全部字节。

例如:

c 复制代码
write(fp->fd, fp->buffer, 100);

我们希望写入 100 字节,但实际可能只写入 60 字节。

此时如果直接把 pos 设置为 0,就会导致剩余 40 字节丢失。

因此,我们需要处理两种情况:

  • 写入成功一部分:继续写入剩余数据。
  • 写入过程中发生错误:保留还没有写入的数据,不能直接清空缓冲区。

代码:

c 复制代码
int my_fflush(MyFILE* fp)
{
    if (fp == NULL)
    {
        errno = EINVAL;
        return -1;
    }

    size_t written = 0;

    while (written < fp->pos)
    {
        ssize_t n = write(fp->fd,
                          fp->buffer + written,
                          fp->pos - written);

        if (n > 0)
        {
            written += (size_t)n;
        }
        else if (n == -1 && errno == EINTR)
        {
            // 被信号中断,继续尝试写入
            continue;
        }
        else
        {
            // 写入失败,保留尚未写入的数据
            size_t remaining = fp->pos - written;

            memmove(fp->buffer,
                    fp->buffer + written,
                    remaining);

            fp->pos = remaining;

            if (n == 0)
            {
                errno = EIO;
            }

            return -1;
        }
    }

    // 所有数据都已经写入
    fp->pos = 0;

    return 0;
}

我们重点看几个地方。

1. 为什么需要 written?

c 复制代码
size_t written = 0;

它记录当前已经成功写入内核的字节数。

假设缓冲区中有 100 字节:

text 复制代码
buffer:

+--------------------------------------+
|              100 字节                |
+--------------------------------------+

第一次 write() 成功写入 60 字节:

text 复制代码
written = 60

那么剩下的数据就是:

c 复制代码
fp->buffer + written

也就是:

c 复制代码
fp->buffer + 60

下一次就从第 61 个字节开始继续写。

2. 为什么要处理 EINTR?

c 复制代码
else if (n == -1 && errno == EINTR)
{
    continue;
}

EINTR 表示系统调用被信号中断。

在没有成功写入数据的情况下,我们可以重新尝试这次写入。

因此不能简单地把所有 write() 失败都当成永久错误。

3. 为什么失败时要使用 memmove()?

假设缓冲区有 100 字节,已经成功写入 60 字节,但后续写入失败。

此时还剩下 40 字节:

text 复制代码
原缓冲区:

+----------------------+----------------------+
| 已经写入的 60 字节   | 尚未写入的 40 字节   |
+----------------------+----------------------+
                       ↑
                    written

已经写入的 60 字节不需要保留。

但是后面的 40 字节不能丢弃。

因此使用:

c 复制代码
memmove(fp->buffer,
        fp->buffer + written,
        remaining);

把剩余数据移动到缓冲区开头。

然后:

c 复制代码
fp->pos = remaining;

这样下一次调用 my_fflush() 时,就可以继续处理剩余数据。

这里使用 memmove() 而不是 memcpy(),是因为源区域和目标区域可能发生重叠。

这一步体现了一个重要的设计原则:

刷新缓冲区时,只有确认数据已经成功写入,才能把对应的数据从缓冲区中移除。


六、实现 my_fwrite():先写入缓冲区,而不是直接调用 write()

注意返回值语义 :my_fwrite() 返回的是已经成功接收进用户态缓冲区的字节数 ,并不代表这些数据已经写入文件。即使返回 size,其中仍可能有部分数据停留在缓冲区,等待后续 my_fflush() 或 my_fclose() 提交。调用方必须结合刷新/关闭的返回值判断数据是否真正落盘。

现在我们已经能够刷新缓冲区了。

接下来实现写入函数:

c 复制代码
size_t my_fwrite(const void* ptr,
                 size_t size,
                 MyFILE* fp);

这里为了让接口简单一些,我们把 size 定义为要写入的总字节数,而不是标准库 fwrite() 中的单个元素大小。

例如:

c 复制代码
my_fwrite("hello", 5, fp);

表示向文件流中写入 5 个字节。

实现思路:

  1. 计算缓冲区剩余空间。
  2. 计算本次可以复制多少字节。
  3. 使用 memcpy() 将数据复制到缓冲区。
  4. 更新 pos。
  5. 如果缓冲区已经满了,就调用 my_fflush()。
  6. 继续处理剩余数据,直到全部复制完成或者发生错误。

代码:

c 复制代码
size_t my_fwrite(const void* ptr,
                 size_t size,
                 MyFILE* fp)
{
    if (fp == NULL || (ptr == NULL && size != 0))
    {
        errno = EINVAL;
        return 0;
    }

    const char* src = (const char*)ptr;
    size_t total = 0;

    while (total < size)
    {
        // 计算缓冲区剩余空间
        size_t space = BUFFER_SIZE - fp->pos;

        // 本次最多复制这么多数据
        size_t n = size - total;

        if (n > space)
        {
            n = space;
        }

        // 把数据复制到用户态缓冲区
        memcpy(fp->buffer + fp->pos,
               src + total,
               n);

        fp->pos += n;
        total += n;

        // 缓冲区满了,刷新
        if (fp->pos == BUFFER_SIZE)
        {
            if (my_fflush(fp) == -1)
            {
                return total;
            }
        }
    }

    return total;
}

这里最重要的是:

c 复制代码
memcpy(fp->buffer + fp->pos,
       src + total,
       n);

我们并没有直接调用 write()。

而是先将数据复制到用户态缓冲区。

只有:

c 复制代码
if (fp->pos == BUFFER_SIZE)
{
    my_fflush(fp);
}

缓冲区满了,才真正触发底层写入。

这就是缓冲机制的核心。

另外,这个教学版函数返回的是已经成功接收到缓冲区中的字节数 ,不是标准库 fwrite() 的返回语义。

如果刷新过程中发生错误,函数可能返回一个非零值,但这不代表这些数据已经全部写入文件。调用者仍然需要检查刷新结果。


七、实现 my_fclose():关闭文件之前先刷新缓冲区

最后一个函数:

c 复制代码
int my_fclose(MyFILE* fp);

为什么关闭文件之前需要先刷新?

考虑下面的情况:

c 复制代码
MyFILE* fp = my_fopen("log.txt");

my_fwrite("hello", 5, fp);

此时:

text 复制代码
用户态缓冲区:

+---+---+---+---+---+
| h | e | l | l | o |
+---+---+---+---+---+

pos = 5

数据还在用户态缓冲区中。

如果直接关闭文件描述符:

c 复制代码
close(fp->fd);

那么这 5 个字节就没有机会通过 write() 提交给内核。

所以,关闭文件流时应该按照下面的顺序:

text 复制代码
my_fclose()
     |
     v
my_fflush()
     |
     v
write()
     |
     v
close(fd)
     |
     v
free(fp)

代码:

c 复制代码
int my_fclose(MyFILE* fp)
{
    if (fp == NULL)
    {
        errno = EINVAL;
        return -1;
    }

    int result = 0;
    int saved_errno = 0;

    // 先刷新缓冲区
    if (my_fflush(fp) == -1)
    {
        result = -1;
        saved_errno = errno;
    }

    // 无论刷新是否成功,都尽力关闭文件描述符
    if (close(fp->fd) == -1 && result == 0)
    {
        result = -1;
        saved_errno = errno;
    }

    // 释放结构体
    free(fp);

    if (result == -1)
    {
        errno = saved_errno;
    }

    return result;
}

这里需要注意:

如果 my_fflush() 失败,说明仍可能有数据没有成功写入。

但是我们依然要尽力关闭文件描述符,并释放结构体。

因此,my_fclose() 会返回错误,提醒调用者刷新或关闭过程出现了问题。

关闭文件流并不意味着所有数据一定已经成功保存。 如果刷新失败,剩余数据可能无法恢复,因为结构体最终会被释放。


八、完整代码:把 MyFILE 串起来

到这里,我们已经实现了四个核心函数:

函数 作用
my_fopen() 打开文件,创建 MyFILE
my_fwrite() 将数据写入用户态缓冲区
my_fflush() 将缓冲区数据通过 write 写入内核
my_fclose() 刷新缓冲区、关闭文件、释放结构体

下面将它们放在一起。

c 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#define BUFFER_SIZE 1024

typedef struct MyFILE
{
    int fd;
    char buffer[BUFFER_SIZE];
    size_t pos;
} MyFILE;

// 打开文件
MyFILE* my_fopen(const char* filename)
{
    int fd = open(filename,
                  O_WRONLY | O_CREAT | O_TRUNC,
                  0666);

    if (fd == -1)
    {
        return NULL;
    }

    MyFILE* fp = (MyFILE*)malloc(sizeof(MyFILE));

    if (fp == NULL)
    {
        int saved_errno = errno;
        close(fd);
        errno = saved_errno;
        return NULL;
    }

    fp->fd = fd;
    fp->pos = 0;

    return fp;
}

// 刷新缓冲区
int my_fflush(MyFILE* fp)
{
    if (fp == NULL)
    {
        errno = EINVAL;
        return -1;
    }

    size_t written = 0;

    while (written < fp->pos)
    {
        ssize_t n = write(fp->fd,
                          fp->buffer + written,
                          fp->pos - written);

        if (n > 0)
        {
            written += (size_t)n;
        }
        else if (n == -1 && errno == EINTR)
        {
            continue;
        }
        else
        {
            size_t remaining = fp->pos - written;

            memmove(fp->buffer,
                    fp->buffer + written,
                    remaining);

            fp->pos = remaining;

            if (n == 0)
            {
                errno = EIO;
            }

            return -1;
        }
    }

    fp->pos = 0;
    return 0;
}

// 写入数据
size_t my_fwrite(const void* ptr,
                 size_t size,
                 MyFILE* fp)
{
    if (fp == NULL || (ptr == NULL && size != 0))
    {
        errno = EINVAL;
        return 0;
    }

    const char* src = (const char*)ptr;
    size_t total = 0;

    while (total < size)
    {
        size_t space = BUFFER_SIZE - fp->pos;
        size_t n = size - total;

        if (n > space)
        {
            n = space;
        }

        memcpy(fp->buffer + fp->pos,
               src + total,
               n);

        fp->pos += n;
        total += n;

        if (fp->pos == BUFFER_SIZE)
        {
            if (my_fflush(fp) == -1)
            {
                return total;
            }
        }
    }

    return total;
}

// 关闭文件
int my_fclose(MyFILE* fp)
{
    if (fp == NULL)
    {
        errno = EINVAL;
        return -1;
    }

    int result = 0;
    int saved_errno = 0;

    if (my_fflush(fp) == -1)
    {
        result = -1;
        saved_errno = errno;
    }

    if (close(fp->fd) == -1 && result == 0)
    {
        result = -1;
        saved_errno = errno;
    }

    free(fp);

    if (result == -1)
    {
        errno = saved_errno;
    }

    return result;
}

int main(void)
{
    MyFILE* fp = my_fopen("log.txt");

    if (fp == NULL)
    {
        perror("my_fopen");
        return 1;
    }

    const char* msg = "hello Linux MyFILE!\n";

    size_t len = strlen(msg);

    size_t n = my_fwrite(msg, len, fp);

    if (n != len)
    {
        fprintf(stderr, "my_fwrite failed\n");
        my_fclose(fp);
        return 1;
    }

    printf("data has been copied into MyFILE buffer\n");

    if (my_fflush(fp) == -1)
    {
        perror("my_fflush");
        my_fclose(fp);
        return 1;
    }

    printf("buffer has been flushed\n");

    if (my_fclose(fp) == -1)
    {
        perror("my_fclose");
        return 1;
    }

    printf("file closed\n");

    return 0;
}

九、编译运行:观察缓冲区的工作过程

1. 编译

假设代码保存为 myfile.c:

bash 复制代码
gcc myfile.c -o myfile

2. 运行

bash 复制代码
./myfile

预期输出:

text 复制代码
data has been copied into MyFILE buffer
buffer has been flushed
file closed

然后查看文件:

bash 复制代码
cat log.txt

预期内容:

text 复制代码
hello Linux MyFILE!

3. 观察缓冲区刷新前后的变化

我们可以在 main() 中加入:

c 复制代码
printf("before flush, pos = %zu\n", fp->pos);

my_fflush(fp);

printf("after flush, pos = %zu\n", fp->pos);

对于这条长度小于 1024 字节的字符串,预期结果是:

text 复制代码
before flush, pos = 20
after flush, pos = 0

这里的数字取决于实际字符串长度。

它说明:

  • my_fwrite() 把数据复制进缓冲区后,pos 增加。
  • my_fflush() 成功写入全部数据后,pos 被重置为 0。

这就验证了我们设计的缓冲区管理逻辑。

5. 缓冲区填满时自动刷新

前面的示例只写入了 20 字节,靠手动调用 my_fflush() 才触发底层写入,读者看不到"缓冲区满自动刷新"这一核心机制。下面写一个超过 BUFFER_SIZE 的示例来观察它。

c 复制代码
int main(void)
{
    MyFILE* fp = my_fopen("big.txt");
    if (fp == NULL)
    {
        perror("my_fopen");
        return 1;
    }

    char chunk[100];
    memset(chunk, 'A', sizeof(chunk));

    // 写入 3000 字节,超过 1024 字节的缓冲区
    for (int i = 0; i < 30; i++)
    {
        my_fwrite(chunk, sizeof(chunk), fp);
        printf("after write #%d, pos = %zu\n", i + 1, fp->pos);
    }

    if (my_fclose(fp) == -1)
    {
        perror("my_fclose");
        return 1;
    }

    return 0;
}

运行后可以观察到:pos 会从 0 逐渐增长,每当累计到 1024 字节时被 my_fflush() 清零,随后继续增长。这说明缓冲区一旦填满就会自动触发一次底层 write(),而不需要调用者手动刷新。

4. 为什么缓冲区能够减少系统调用?

还可以使用 strace 观察系统调用:

bash 复制代码
strace -e trace=write ./myfile

可以看到程序执行过程中出现的 write() 调用。

注意,程序中的 printf() 也可能产生 write(),所以不能简单地把所有 write() 都算作 MyFILE 的写入。

如果想更清楚地观察,可以把调试输出和 MyFILE 写入分开分析,重点关注写入 log.txt 对应文件描述符的系统调用。

另外,当前示例主动调用了一次 my_fflush(),所以即使数据没有填满缓冲区,也会发生一次底层写入。

如果去掉主动刷新,只在 my_fclose() 时刷新,那么这段短字符串就会在关闭时才提交。


十、回到最初的问题:FILE 为什么需要缓冲区?

现在我们已经亲手实现了一个简易的 MyFILE,可以重新理解 C 标准 I/O 的设计。

假设程序需要向文件写入 10000 个字节。

如果每写入 1 个字节都直接调用一次 write():

text 复制代码
写入 1 字节 -> write()
写入 1 字节 -> write()
写入 1 字节 -> write()
...

那么就需要进行大量系统调用。

而有了缓冲区:

text 复制代码
程序写入数据
      |
      v
用户态缓冲区暂存数据
      |
      v
缓冲区达到一定容量
      |
      v
一次 write() 写入一批数据

这样就可以减少系统调用次数,降低频繁进行用户态与内核态切换的开销。

当然,缓冲区并不是越大越好,也不是所有数据都必须等到缓冲区满了才写入。

实际的标准 I/O 库会根据缓冲模式、流的状态以及调用者的操作来决定何时刷新。

我们自己实现的版本只是最基础的教学模型。

还需要区分:用户态缓冲区和内核页缓存

这里再补充一个容易混淆的概念。

当我们调用:

c 复制代码
write(fd, buffer, size);

数据从用户态提交给内核后,并不意味着它已经立即写入物理磁盘。

对于常见的普通文件写入,内核通常还会使用页缓存(Page Cache)管理文件数据。

所以整个过程可以理解为:

text 复制代码
应用程序
   |
   v
MyFILE 用户态缓冲区
   |
   | write()
   v
内核
   |
   v
Page Cache(页缓存)
   |
   v
存储设备

这意味着:

  • my_fflush():把我们自己管理的用户态缓冲区提交给内核。
  • write():完成从用户空间向内核的写入操作。
  • fsync():用于请求内核将文件相关的修改同步到存储设备。

因此,my_fflush() 成功不等于数据已经物理落盘。

这几个层次需要分清楚。


十一、这个 MyFILE 还缺什么?

我们实现的 MyFILE 是一个教学模型,距离真正的 C 标准库 FILE 还有不少差距。明确这些局限,有助于理解真实实现为什么那么复杂:

  • 只支持 "w" 模式 :不支持读模式、追加模式("a")、读写混合模式("r+")。
  • 缓冲区大小固定:真实实现会根据文件类型(终端、管道、普通文件)选择全缓冲、行缓冲或无缓冲。
  • 没有文件偏移管理 :不支持 fseek()、ftell()、rewind()。
  • 没有格式化 I/O :不支持 fprintf()、fscanf() 等。
  • 不是线程安全的 :真实 FILE 内部有锁,保证多线程并发调用安全。
  • 错误处理较简化 :没有统一的错误标志位(如 ferror()、feof()),也没有 clearerr()。
  • 未处理 write 返回 0 的完整语义:普通文件上返回 0 通常意味着异常,但管道、非阻塞 fd 等场景需要更细致的处理。

如果想进一步深入,可以对照 glibc 的 _IO_FILE 结构体,看看真实实现是如何在 fd、缓冲区、锁、状态标志之间协作的。

十一、本篇总结

这一篇我们从零设计了一个简易的 MyFILE,实现了:

  • my_fopen():打开文件并创建流对象。
  • my_fwrite():将数据复制到用户态缓冲区。
  • my_fflush():通过 write() 将缓冲区数据提交给内核。
  • my_fclose():刷新数据、关闭文件描述符并释放结构体。

整个实现最重要的不是函数本身,而是理解三个成员之间的关系:

text 复制代码
MyFILE
  |
  +---- fd
  |       |
  |       v
  |   文件描述符表
  |       |
  |       v
  |   内核文件对象
  |
  +---- buffer
  |       |
  |       v
  |   暂存待写入的数据
  |
  +---- pos
          |
          v
      记录有效数据量

记住:my_fwrite() 负责把数据放进缓冲区,my_fflush() 负责把缓冲区中的数据交给内核。

这就是本篇最核心的逻辑。

本篇复习 Checklist

  • 能够解释 FILE* 和文件描述符之间的关系。
  • 能够说清楚为什么需要用户态缓冲区。
  • 能够解释 buffer、fd、pos 三个成员的作用。
  • 能够独立写出 my_fopen()。
  • 能够解释 my_fwrite() 为什么不需要每次都调用 write()。
  • 能够讲清楚 my_fflush() 的刷新过程。
  • 能够解释为什么需要处理 write() 部分写入。
  • 能够解释为什么关闭文件之前需要刷新缓冲区。
  • 能够区分用户态缓冲区、内核页缓存和物理磁盘。

下一篇预告

Linux 文件篇(六):Shell 实战------从文件描述符到输入输出重定向

前面五篇,我们已经从文件描述符、系统调用、dup2()、FILE* 一直学习到了缓冲区机制。

最后一篇,我们回到自己实现的 Shell:

当用户输入:

bash 复制代码
./mycmd > log.txt

Shell 到底做了什么?

为什么只需要改变文件描述符的指向,就能让程序的输出进入文件?

下一篇将结合自定义 Shell,把前面学习的文件 I/O 知识真正串起来。

相关推荐
蜗牛一步步往上爬33 分钟前
第十章 使用编辑器
linux
摇滚侠2 小时前
《On Java 中文版 基础卷》阅读笔记 接口 18
java·笔记·python
电科_银尘2 小时前
【大模型算法与工程 27】训练配方:批量、学习率、精度与梯度裁剪
学习·算法·机器学习
无足鸟ICT5 小时前
【RHCA+】swap和物理内存
linux
江屿风6 小时前
AI Agent架构全解析:从规划到记忆的智能跃迁
人工智能·笔记·架构·agent·c/s·mcp工作流
zly35006 小时前
esxi安装 windows2000 鼠标不动
运维·服务器
LabVIEW开发7 小时前
Ethernet/IP 会话无效 -251723770
服务器·网络协议·tcp/ip
fly_sunnn9 小时前
机械狗的前置学习(python与Linux基础操作)
学习
老花眼猫9 小时前
C语言绘图方法:(14)长方体旋转
c语言·经验分享·青少年编程·课程设计