一、为什么要自己实现一个 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,本质上就是自己管理这两个东西:
- 一个文件描述符,负责连接内核中的文件对象。
- 一块用户态缓冲区,负责暂存程序准备写入的数据。
三、设计 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" 模式,也就是创建文件或者清空已有文件。
实现步骤:
- 调用
open()打开文件。 - 使用
malloc()申请MyFILE结构体空间。 - 初始化文件描述符和缓冲区使用量。
- 返回结构体指针。
代码:
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 个字节。
实现思路:
- 计算缓冲区剩余空间。
- 计算本次可以复制多少字节。
- 使用
memcpy()将数据复制到缓冲区。 - 更新
pos。 - 如果缓冲区已经满了,就调用
my_fflush()。 - 继续处理剩余数据,直到全部复制完成或者发生错误。
代码:
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 知识真正串起来。