#include <stdio.h>
int main(void)
{
FILE *fp = fopen("myfile", "w");
if (fp == NULL) {
perror("fopen");
return 1;
}
fwrite("hello\n", 1, 6, fp);
fclose(fp);
return 0;
}fopen 返回一个 FILE *,fwrite 往这个流里写,fclose 关闭。看起来是 C 库在管文件,实际每一步最终都要落到 open、write、close 三个系统调用上。理解 IO 的关键是把这两层分开:用户态的 FILE 和内核里的文件对象。
文件是属性加内容,读写都要经过内核
文件在磁盘上,磁盘是永久存储介质,也是外设。文件由两部分组成:内容(数据块)和属性(元数据,包括名字、大小、权限、时间戳、inode 编号)。0 字节的空文件不占数据块,但仍要占 inode 和目录项,所以“空文件不占磁盘”是错的。对文件的操作只有两类:改内容,或改属性。
Linux 把设备也抽象成文件:键盘、显示器、网卡、磁盘、管道、套接字都能用 read、write、open、close 访问。内核为每个打开的文件建立一个 struct file,里面的 f_op 指向一组函数指针,不同设备挂不同的 read/write 实现,VFS 按 f_op 分发。开发者只拿一个 fd,就能用同一套接口操作绝大部分资源。

文件的管理者是操作系统。应用不能直接操作磁盘,读写请求要经过系统调用进入内核,由内核的文件系统和驱动完成。C 库函数只是把系统调用包了一层,方便使用。

C 标准库:FILE * 和六种打开方式
stdin、stdout、stderr 是三个全局 FILE *,进程启动时自动打开,分别对应标准输入、标准输出、标准错误。fopen 的第二个参数决定打开方式:
| 模式 | 行为 |
|---|---|
r | 只读,文件必须存在,位置在开头 |
r+ | 读写,文件必须存在,位置在开头 |
w | 只写,文件不存在就创建,存在就截断为 0,位置在开头 |
w+ | 读写,不存在就创建,存在就截断 |
a | 追加写,不存在就创建,写入位置在末尾 |
a+ | 读和追加写,读从开头,写始终追加到末尾 |
fwrite(ptr, size, nmemb, stream) 按“每个元素 size 字节、共 nmemb 个”写入,返回成功写入的元素个数;fread 同理。读文件时不要用 while (!feof(fp)) 作循环条件,因为 feof 只有在一次读操作失败后才置位,循环体可能多跑一次。按返回值判断更稳:
#include <stdio.h>
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "usage: %s file\n", argv[0]);
return 1;
}
FILE *fp = fopen(argv[1], "r");
if (fp == NULL) {
perror("fopen");
return 2;
}
char buf[1024];
size_t n;
while ((n = fread(buf, 1, sizeof(buf), fp)) > 0)
fwrite(buf, 1, n, stdout);
if (ferror(fp)) {
fprintf(stderr, "fread error\n");
fclose(fp);
return 3;
}
fclose(fp);
return 0;
}fread 返回 0 时可能是读到了文件末尾,也可能是出错;用 feof(fp) 和 ferror(fp) 区分。fwrite、printf、fprintf(stdout, ...) 都是往标准输出写,fprintf(stderr, ...) 往标准错误写。
系统调用:open 的 flags 是位或出来的
系统调用接口更底层,参数用整数和指针,不隐藏任何细节。open 的 flags 是多个常量按位或组合出来的,每个常量占一个二进制位,这种传参方式在系统接口里很常见:
#include <stdio.h>
#define ONE 0001
#define TWO 0002
#define THREE 0004
void show(int flags)
{
if (flags & ONE) printf("ONE ");
if (flags & TWO) printf("TWO ");
if (flags & THREE) printf("THREE ");
printf("\n");
}
int main(void)
{
show(ONE);
show(ONE | TWO);
show(ONE | TWO | THREE);
return 0;
}open 的常用标志:
| 标志 | 含义 |
|---|---|
O_RDONLY | 只读,值为 0 |
O_WRONLY | 只写 |
O_RDWR | 读写 |
O_CREAT | 文件不存在就创建,必须提供 mode |
O_TRUNC | 打开时把文件长度截断为 0 |
O_APPEND | 每次写入都追加到文件末尾 |
O_EXCL | 与 O_CREAT 连用,文件已存在就失败 |
前三个访问模式必须指定且只能指定一个。O_CREAT 需要第三个参数 mode,表示新建文件的权限,最终还会被 umask 修正;不创建文件时用两参数版本即可。
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
umask(0);
int fd = open("myfile", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0) {
perror("open");
return 1;
}
const char *msg = "hello bit\n";
for (int i = 0; i < 5; i++) {
if (write(fd, msg, strlen(msg)) < 0) {
perror("write");
close(fd);
return 1;
}
}
close(fd);
return 0;
}write(fd, buf, count) 把 buf 开头的 count 字节写进去,返回实际写入的字节数,可能小于 count;read(fd, buf, count) 返回实际读到的字节数,返回 0 表示读到末尾,返回 -1 表示出错。close(fd) 释放这个描述符。lseek(fd, offset, whence) 改读写位置,whence 可以是 SEEK_SET、SEEK_CUR、SEEK_END,返回新位置。
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main(void)
{
int fd = open("myfile", O_RDONLY);
if (fd < 0) {
perror("open");
return 1;
}
char buf[1024];
ssize_t n;
while ((n = read(fd, buf, sizeof(buf))) > 0) {
if (write(1, buf, n) < 0) {
perror("write");
close(fd);
return 1;
}
}
if (n < 0)
perror("read");
close(fd);
return 0;
}fd 是 fd_array 的下标,重定向就是换指针
每个进程的 task_struct 里有一个 files 指针,指向 files_struct。这张表的核心是一个指针数组 fd_array,每个元素指向一个已打开文件的 struct file。文件描述符就是这个数组的下标,拿到 fd 就拿到了对应的文件对象。

课件的说法是“0、1、2 对应的物理设备一般是键盘、显示器、显示器”。更准确的说法是:0、1、2 默认从父进程继承,交互式 shell 下通常都指向同一个控制终端;0 走读方向,1 和 2 走写方向。标准输入可以被重定向成普通文件或管道,标准输出也可以指向文件,它们并不绑定在键盘和显示器上。
分配规则很简单:在 fd_array 里找当前没被用的最小下标。进程启动时 0、1、2 已占用,第一次 open 得到 3;先 close(0) 再 open,新文件就拿到 0。
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main(void)
{
close(0);
int fd = open("myfile", O_RDONLY);
if (fd < 0) {
perror("open");
return 1;
}
printf("fd = %d\n", fd);
close(fd);
return 0;
}这段程序打印 0,因为 0 号槽位被腾出来了。把 close(0) 换成 close(2),会打印 2。规则不依赖文件名、内容或打开方式,只看下标有没有被占。
dup2(oldfd, newfd) 让 newfd 也指向 oldfd 对应的文件对象:如果 newfd 已经打开,先关掉它;操作成功后两个描述符共享同一个打开文件描述(包括读写偏移)。重定向的本质就是把 1 号槽位的指针换成另一个文件的指针。
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main(void)
{
int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0) {
perror("open");
return 1;
}
if (dup2(fd, 1) < 0) {
perror("dup2");
close(fd);
return 1;
}
printf("this line goes to log.txt\n");
fflush(stdout);
close(fd);
return 0;
}printf 仍然往 stdout 写,stdout 底层用的是 fd 1;fd 1 现在指向 log.txt,内容就进了文件。

课件的 dup2 示例里写的是 open("./log", O_CREAT | O_RDWR),少了第三个 mode 参数。open(2) 明确规定:使用 O_CREAT 时必须提供 mode,否则新建文件的权限取自不确定的值。正确写法是 open("./log", O_CREAT | O_RDWR, 0644)。示例里先 close(1) 再 dup2(fd, 1) 也多余,dup2 本身会关掉已打开的 newfd。
dup2 的兄弟是 dup(oldfd):它不指定新下标,直接返回当前最小的可用 fd,语义和 dup2(oldfd, 最小可用) 一样。两个函数复制的是“打开文件描述”,不是文件本身;复制出来的 fd 和原 fd 共享同一个读写偏移,往一个 fd 写,另一个 fd 的 lseek 位置也跟着走。fork 之后父子进程的 fd 表也是这种关系:子进程继承的是指向同一批 struct file 的指针,所以父子往同一个文件追加时,偏移是共享的。
shell 的 >、>>、<、2>&1 都落在这套操作上:> 用 O_WRONLY|O_CREAT|O_TRUNC 打开目标文件再 dup2 到 1;>> 把 O_TRUNC 换成 O_APPEND;< 打开文件后 dup2 到 0;2>&1 把 1 号槽位的指针复制到 2 号。重定向要在子进程 exec 之前做,exec 会保留 fd 表,新程序继承的就是已经改过的 0、1、2。
缓冲区:stdio 一层,内核页缓存一层
每次 read、write 都是一次系统调用,要从用户态切到内核态,开销不小。stdio 在用户空间准备一块缓冲,把多次小写入攒成一次系统调用;内核又在页缓存里缓存磁盘块,减少真正的磁盘访问。
标准 I/O 有三种缓冲方式:
| 类型 | 刷新时机 | 典型对象 |
|---|---|---|
| 全缓冲 | 缓冲区满、fflush、fclose、exit | 普通磁盘文件 |
| 行缓冲 | 遇到 \n、缓冲区满、fflush、fclose、exit | 终端上的 stdin、stdout |
| 无缓冲 | 每次调用直接进内核 | stderr,以及 setvbuf 设置成 _IONBF 的流 |
课件写“默认行缓冲区大小为 1024”。这个大小由实现决定,glibc 用的是 BUFSIZ,在 glibc 里是 8192 字节,不是固定 1024;换一个 libc 实现可能又是别的值,所以不要拿 1024 当地址或边界来推算。
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int main(void)
{
printf("hello printf\n");
fwrite("hello fwrite\n", 1, strlen("hello fwrite\n"), stdout);
write(1, "hello write\n", strlen("hello write\n"));
fork();
return 0;
}在终端上跑,三行各出现一次。加 > out.txt 重定向到文件后,out.txt 里有五行:write 一行,printf 和 fwrite 各两行。
原因分两层。终端上的 stdout 是行缓冲,三条输出都带 \n,在 fork 之前就已刷进内核,父子各有一份已经清空的用户缓冲。重定向到普通文件后,stdout 变成全缓冲,printf 和 fwrite 的内容还留在 FILE 的用户缓冲区里;fork 复制地址空间时,这块缓冲区也按写时拷贝复制了一份。父子进程各自在退出时刷新,各自写一次,于是两行变四行。write 不经过 stdio 的用户缓冲,直接进内核,所以只有一行。
课件里还有一个“重定向后内容丢失”的例子:先 close(1),再 open 得到 fd 1,printf 写内容,随后 close(fd)。课件把这个现象归因于“缓冲区没填满”。全缓冲确实会让内容留在用户态,但进程正常退出时 stdio 会刷新所有流,内容本可以写出去;真正让它丢掉的是那句 close(fd)——fd 1 已经被关闭,退出时刷新往 1 号描述符写会得到 EBADF。把 close(fd) 之前加一句 fflush(stdout),或者改用 fclose(stdout),内容就能落盘。
内核页缓存是另一层。write 返回成功,只表示数据已经交给内核并放进页缓存,不表示已经落到磁盘;fsync(fd) 才会要求把脏页写回设备。read 命中页缓存时不用访问磁盘。断电丢数据、write 成功但文件里没有,这类问题都出在这一层,和 stdio 的用户缓冲不是一回事。
FILE 里封装着 fd,自己写一个 mini stdio
FILE 在 glibc 里定义为 struct _IO_FILE,里面除了标志位,主要是三组指针和底层 fd:
| 字段 | 作用 |
|---|---|
_flags | 高位是魔数,低位是流的状态标志 |
_IO_read_ptr / _IO_read_end / _IO_read_base | 读缓冲区的当前指针、末尾和起点 |
_IO_write_base / _IO_write_ptr / _IO_write_end | 写缓冲区的起点、当前指针和末尾 |
_IO_buf_base / _IO_buf_end | 整个缓冲区的起止地址 |
_fileno | 底层文件描述符 |
_fileno 就是底层的文件描述符。fileno(FILE *) 返回它;fdopen(fd, mode) 反过来,把一个已有的 fd 包成 FILE *。这说明“库函数”和“系统调用”不是两套独立的文件系统,库函数只是在 fd 上面加了一层缓冲和格式化。
自己实现一个最小版本,可以把这层关系看清。头文件:
#pragma once
#define SIZE 1024
#define FLUSH_NONE 0
#define FLUSH_LINE 1
#define FLUSH_FULL 2
struct IO_FILE {
int flags;
int fileno;
char outbuffer[SIZE];
int size;
};
typedef struct IO_FILE mFILE;
mFILE *mfopen(const char *path, const char *mode);
int mfwrite(const void *ptr, int num, mFILE *stream);
void mfflush(mFILE *stream);
void mfclose(mFILE *stream);实现:
#include "my_stdio.h"
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
mFILE *mfopen(const char *path, const char *mode)
{
int fd = -1;
if (strcmp(mode, "r") == 0)
fd = open(path, O_RDONLY);
else if (strcmp(mode, "w") == 0)
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
else if (strcmp(mode, "a") == 0)
fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
else
return NULL;
if (fd < 0)
return NULL;
mFILE *f = (mFILE *)malloc(sizeof(*f));
if (f == NULL) {
close(fd);
return NULL;
}
f->fileno = fd;
f->size = 0;
f->flags = (fd == 1 || fd == 2) ? FLUSH_LINE : FLUSH_FULL;
return f;
}
void mfflush(mFILE *stream)
{
if (stream->size > 0) {
write(stream->fileno, stream->outbuffer, stream->size);
stream->size = 0;
}
}
int mfwrite(const void *ptr, int num, mFILE *stream)
{
const char *p = (const char *)ptr;
int left = num;
while (left > 0) {
if (stream->size == SIZE)
mfflush(stream);
int room = SIZE - stream->size;
int n = left < room ? left : room;
memcpy(stream->outbuffer + stream->size, p, n);
stream->size += n;
p += n;
left -= n;
if (stream->flags == FLUSH_LINE && stream->size > 0 &&
stream->outbuffer[stream->size - 1] == '\n')
mfflush(stream);
}
return num;
}
void mfclose(mFILE *stream)
{
if (stream->size > 0)
mfflush(stream);
close(stream->fileno);
free(stream);
}#include "my_stdio.h"
int main(void)
{
mFILE *f = mfopen("log.txt", "a");
if (f == NULL)
return 1;
mfwrite("hello\n", 6, f);
mfwrite("world\n", 6, f);
mfclose(f);
return 0;
}mfopen 把 mode 映射成 open 的 flags,mfwrite 只往用户缓冲里拷贝,缓冲满或这次写入的最后一个字节是换行时才调用 write,mfclose 先刷新再 close(fd)。这套代码没有 printf 的格式化功能,也没有线程安全和写入失败后的回滚,但结构已经和 glibc 的 FILE 一致:一个 fd,一块缓冲,一套刷新规则。
从 fopen 到 open,从 FILE * 到 fd,从用户缓冲到页缓存,链路走通之后,“重定向为什么能改变 printf 的去向”“为什么 write 不受缓冲影响”“为什么 fork 后多出两行”就不再是三个孤立的怪现象,而是同一个模型在不同参数下的结果。
还没有评论 — 第一条由你来留。