【Linux系统编程】（十九）深入 Linux 文件与文件 IO：从底层原理到实战操作，一文吃透！

_OP_CHEN2026-01-24 8:01

前言

在 Linux 中，"文件" 是一个贯穿始终的核心概念，而文件 IO（输入 / 输出）则是程序员与系统交互的基础手段。无论是日常的文件读写、设备操作，还是复杂的网络通信、进程间通信，背后都离不开文件与文件 IO 的支撑。

很多初学者在接触 Linux 文件 IO 时，往往会被 C 库函数、系统调用、文件描述符、缓冲区这些概念搞得晕头转向，不清楚它们之间的关联与区别。本文将从 "文件是什么" 出发，逐步深入 C 文件接口、系统文件 IO 的底层实现，带你彻底搞懂 Linux 文件与文件 IO 的核心逻辑，让你从 "会用" 升级到 "懂原理"。下面就让我们正式开始吧！

一、重新认识 Linux 中的 "文件"：不止是磁盘中的文档

提到 "文件"，很多人的第一反应是 "存放在磁盘上的文档"------ 这其实是对文件的狭义理解。在 Linux 系统中，文件的概念被极大地拓展了，理解这一点是掌握 Linux 文件 IO 的关键。

1.1 狭义的文件：磁盘上的永久存储

从狭义上讲，文件是存储在磁盘等永久性存储介质上的数据集合。磁盘作为计算机的外设（兼具输入和输出功能），其上的文件不会因断电而丢失，这也是 "永久性存储" 的核心特点。

但你可能会有疑问：一个 0KB 的空文件，明明没有任何内容，为什么会占用磁盘空间？答案很简单：文件 = 属性（元数据）+ 内容。空文件虽然没有实际数据内容，但依然需要存储文件名、创建时间、权限、所属用户组等属性信息，这些元数据会占用少量磁盘空间。

比如我们创建一个空文件，通过ls -l命令可以看到它的属性信息：

bash 复制代码 
touch emptyfile
ls -l emptyfile
# 输出结果：-rw-rw-r-- 1 hyb hyb 0 Aug 26 18:00 emptyfile

其中，**-rw-rw-r--**是权限属性，hyb hyb是所属用户和组，0是文件大小（内容为空），Aug 26 18:00是创建时间，这些都是文件的元数据。

1.2 广义的文件：Linux 的 "万物皆文件" 哲学

Linux 最核心的设计哲学之一就是 "一切皆文件"。在 Linux 系统中，不仅磁盘上的文档是文件，键盘、显示器、网卡、打印机、进程、管道、套接字（socket）等都被抽象成了文件。

这种抽象设计带来了一个巨大的好处：开发者只需掌握一套 IO 接口，就能操作系统中的绝大部分资源。比如：

  • 读取键盘输入，本质是读取 "键盘文件"；
  • 向显示器输出内容，本质是写入 "显示器文件"；
  • 网络通信中发送数据，本质是写入 "套接字文件"；
  • 查看进程状态，本质是读取/proc目录下的 "进程文件"。

举个直观的例子，我们可以通过cat命令读取**/proc/cpuinfo**文件来查看 CPU 信息，这个文件并不是存储在磁盘上的真实文件，而是内核动态生成的 "虚拟文件"：

bash 复制代码 
cat /proc/cpuinfo

输出的内容就是 CPU 的型号、核心数等信息，这正是 "万物皆文件" 哲学的体现 ------ 通过文件接口统一访问各类系统资源。

1.3 文件操作的本质：进程与系统的交互

无论是操作磁盘文件，还是操作键盘、网卡等设备文件，本质上都是进程对文件的操作。因为进程是操作系统分配资源的基本单位，所有的文件操作都必须通过进程发起。

但这里有个关键知识点：进程并不会直接操作硬件（比如磁盘、键盘）。磁盘等硬件的管理者是操作系统，进程想要操作文件，必须通过操作系统提供的 "系统调用接口" 来请求内核完成相应的操作。

比如我们用 C 语言的fwrite函数向文件写入数据，其底层流程是：

  1. 进程调用 C 库函数fwrite；
  2. fwrite函数封装内核提供的系统调用接口（如write）；
  3. 内核接收系统调用请求，操作磁盘硬件完成数据写入；
  4. 内核将操作结果返回给 C 库函数，再由 C 库函数返回给进程。

简单来说：应用程序（进程）→ 库函数 → 系统调用 → 内核 → 硬件，这就是文件操作的完整链路。

二、回顾 C 文件接口：我们最常用的文件操作方式

在学习 Linux 系统文件 IO 之前，我们先回顾一下 C 语言标准库提供的文件操作接口。这些接口是我们日常开发中最常用的，它们封装了底层的系统调用，使用起来更加便捷。

2.1 打开文件：fopen 函数的使用与路径问题

打开文件是所有文件操作的第一步，C 语言中使用fopen函数打开文件，函数原型如下：

cpp 复制代码 
FILE *fopen(const char *filename, const char *mode);
  • filename：要打开或创建的文件路径（相对路径或绝对路径）；
  • mode：打开文件的模式（如只读、只写、追加等）；
  • 返回值 ：成功返回指向FILE结构体的指针（文件指针），失败返回NULL。

实战代码：打开文件并处理错误

cpp 复制代码 
#include <stdio.h>

int main() {
    // 以只写模式打开当前路径下的myfile文件，不存在则创建
    FILE *fp = fopen("myfile", "w");
    if (!fp) {  // 打开失败的错误处理
        printf("fopen error!\n");
        return 1;
    }
    printf("fopen success!\n");
    fclose(fp);  // 关闭文件
    return 0;
}

编译运行：

bash 复制代码 
gcc -o open_file open_file.c
./open_file
# 输出：fopen success!
ls  # 会看到当前目录下新增了myfile文件

关键问题：系统如何确定文件的路径？

在上面的代码中，我们使用的是相对路径 "myfile"，系统是如何知道这个文件要创建在哪个目录下的？

答案是：进程有自己的 "当前工作目录"（Current Working Directory）。当我们使用相对路径时，系统会默认在进程的当前工作目录下查找或创建文件。

我们可以通过**/proc/[进程ID]/cwd**来查看进程的当前工作目录。比如我们让程序运行时暂停，然后查看其进程信息：

cpp 复制代码 
#include <stdio.h>
#include <unistd.h>  // 包含sleep函数声明

int main() {
    FILE *fp = fopen("myfile", "w");
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    printf("进程运行中，PID：%d\n", getpid());  // 打印进程ID
    sleep(30);  // 暂停30秒，方便我们查看进程信息
    fclose(fp);
    return 0;
}

编译运行后，程序会打印进程 ID 并暂停。此时打开另一个终端，执行以下命令：

bash 复制代码 
ls -l /proc/[进程ID]/cwd

输出结果类似：

bash 复制代码 
lrwxrwxrwx 1 hyb hyb 0 Aug 26 18:10 /proc/12345/cwd -> /home/hyb/io

其中cwd是一个符号链接，指向进程的当前工作目录（这里是/home/hyb/io），这就是系统创建myfile文件的默认路径。

2.2 写入文件：fwrite 函数的使用

打开文件后，我们可以使用fwrite函数向文件写入数据，函数原型如下：

cpp 复制代码 
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
  • ptr：指向要写入数据的缓冲区指针；
  • size：每个数据单元的字节数；
  • nmemb：要写入的数据单元个数；
  • stream：文件指针（fopen的返回值）；
  • 返回值 ：成功写入的数据单元个数，失败返回小于nmemb的值。

实战代码：向文件写入数据

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("myfile", "w");
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    const char *msg = "hello bit!\n";  // 要写入的内容
    int count = 5;  // 写入5次
    while (count--) {
        // 每次写入strlen(msg)个字节，1个数据单元
        fwrite(msg, strlen(msg), 1, fp);
    }
    fclose(fp);  // 关闭文件，刷新缓冲区
    return 0;
}

编译运行后，查看文件内容：

bash 复制代码 
gcc -o write_file write_file.c
./write_file
cat myfile
# 输出：
# hello bit!
# hello bit!
# hello bit!
# hello bit!
# hello bit!

可以看到，fwrite成功将数据写入了文件。这里需要注意的是，fclose函数会在关闭文件前刷新缓冲区，确保数据被写入磁盘，避免数据丢失。

2.3 读取文件：fread 函数与 feof 函数的坑

读取文件使用fread函数，函数原型如下：

cpp 复制代码 
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
  • ptr：指向存储读取数据的缓冲区指针；
  • size：每个数据单元的字节数；
  • nmemb：要读取的数据单元个数；
  • stream：文件指针；
  • 返回值：成功读取的数据单元个数，若到达文件末尾则返回 0。

实战代码：读取文件内容

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("myfile", "r");
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    char buf[1024];  // 缓冲区
    const char *msg = "hello bit!\n";
    size_t msg_len = strlen(msg);
    while (1) {
        // 每次读取msg_len个字节（即一行数据）
        size_t s = fread(buf, 1, msg_len, fp);
        if (s > 0) {  // 成功读取到数据
            buf[s] = '\0';  // 添加字符串结束符
            printf("%s", buf);
        }
        if (feof(fp)) {  // 判断是否到达文件末尾
            break;
        }
    }
    fclose(fp);
    return 0;
}

编译运行：

bash 复制代码 
gcc -o read_file read_file.c
./read_file
# 输出结果与myfile文件内容一致

注意：feof 函数的 "坑"

很多初学者会误以为feof函数是用来判断 "是否还有数据可以读取"，但实际上feof是用来判断 "上一次读取操作是否因为到达文件末尾而失败"。

如果文件内容的字节数刚好是msg_len的整数倍，fread会返回msg_len，此时feof返回 false；当fread返回 0 时，再调用feof才能确定是否到达文件末尾（而不是读取错误）。

扩展：实现简单的 cat 命令

利用fread和fwrite，我们可以实现一个简单的cat命令（用于读取文件内容并输出到显示器）：

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    // 检查参数：必须传入一个文件名
    if (argc != 2) {
        printf("用法：%s <文件名>\n", argv[0]);
        return 1;
    }
    FILE *fp = fopen(argv[1], "r");
    if (!fp) {
        printf("fopen error: 无法打开文件 %s\n", argv[1]);
        return 2;
    }
    char buf[1024];
    while (1) {
        // 每次读取1024个字节
        size_t s = fread(buf, 1, sizeof(buf), fp);
        if (s > 0) {
            buf[s] = '\0';
            printf("%s", buf);
        }
        if (feof(fp)) {
            break;
        }
    }
    fclose(fp);
    return 0;
}

编译运行：

bash 复制代码 
gcc -o mycat mycat.c
./mycat myfile  # 相当于cat myfile命令

2.4 输出到显示器：stdout、printf 与 fprintf

除了操作磁盘文件，我们还经常需要向显示器输出内容。C 语言中，向显示器输出的方式有多种，核心都是操作 "标准输出流"。

三种常用的输出方式

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    const char *msg1 = "hello fwrite\n";
    const char *msg2 = "hello printf\n";
    const char *msg3 = "hello fprintf\n";
    
    // 方式1：fwrite写入stdout
    fwrite(msg1, strlen(msg1), 1, stdout);
    // 方式2：printf（默认输出到stdout）
    printf("%s", msg2);
    // 方式3：fprintf指定stdout
    fprintf(stdout, "%s", msg3);
    
    return 0;
}

编译运行：

bash 复制代码 
gcc -o output_display output_display.c
./output_display
# 输出：
# hello fwrite
# hello printf
# hello fprintf

2.5 标准输入、输出、错误流：stdin、stdout、stderr

C 语言程序启动时，会默认打开三个标准流，它们的类型都是**FILE***（文件指针）：

  • stdin：标准输入流，对应键盘（文件描述符 0）；
  • stdout：标准输出流，对应显示器（文件描述符 1）；
  • stderr：标准错误流，对应显示器（文件描述符 2）。

这三个流是全局可见的，我们可以直接使用。比如从键盘读取输入，再输出到显示器：

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    char buf[1024];
    printf("请输入内容：");
    // 从stdin读取输入
    size_t s = fread(buf, 1, sizeof(buf), stdin);
    if (s > 0) {
        buf[s] = '\0';
        // 向stdout输出
        printf("你输入的内容：%s", buf);
        // 向stderr输出（也是显示器）
        fprintf(stderr, "错误流输出：%s", buf);
    }
    return 0;
}

2.6 fopen 的打开模式详解

fopen函数的**mode**参数决定了文件的打开方式，常用的模式如下：

模式 含义 注意事项
r 只读打开文本文件 文件必须存在，否则打开失败
r+ 读写打开文本文件 文件必须存在，读写指针位于文件开头
w 只写打开文本文件 文件不存在则创建，存在则清空（截断为 0 长度）
w+ 读写打开文本文件 文件不存在则创建，存在则清空
a 追加写打开文本文件 文件不存在则创建，写指针位于文件末尾
a+ 追加写 + 读取文本文件 文件不存在则创建，写指针位于末尾，读指针可移动到开头

示例：追加模式（a）的使用

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("myfile", "a");  // 追加模式
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    const char *msg = "append message!\n";
    fwrite(msg, strlen(msg), 1, fp);
    fclose(fp);
    return 0;
}

运行后查看myfile，会发现内容末尾新增了 "append message!"。

三、系统文件 IO：深入内核的文件操作接口

C 库函数（如fopen、fwrite）虽然方便，但它们是对底层系统调用的封装。要真正理解文件 IO 的本质，必须学习 Linux 内核提供的系统文件 IO 接口。这些接口是内核暴露给用户层的 "原始接口"，所有语言的文件操作最终都依赖它们。

3.1 一种传递标志位的方法：位运算的妙用

在学习系统调用之前，我们先了解一个重要的编程技巧：使用位运算传递多个标志位 。系统调用中很多函数（如open）需要传入多个选项，这些选项就是通过位运算的**"或" 操作** （|）组合而成的。

原理：每个标志位对应一个二进制位

我们定义多个宏，每个宏对应一个二进制位（确保互不冲突），然后通过|组合多个标志，通过&判断某个标志是否被设置。

实战代码：位运算传递标志位

cpp 复制代码 
#include <stdio.h>

// 定义三个标志位，每个对应一个二进制位
#define FLAG_ONE  0x01  // 二进制：0001
#define FLAG_TWO  0x02  // 二进制：0010
#define FLAG_THREE 0x04  // 二进制：0100

// 解析标志位
void parse_flags(int flags) {
    if (flags & FLAG_ONE) {
        printf("标志位包含 FLAG_ONE\n");
    }
    if (flags & FLAG_TWO) {
        printf("标志位包含 FLAG_TWO\n");
    }
    if (flags & FLAG_THREE) {
        printf("标志位包含 FLAG_THREE\n");
    }
    printf("------------------------\n");
}

int main() {
    parse_flags(FLAG_ONE);  // 只传FLAG_ONE
    parse_flags(FLAG_ONE | FLAG_TWO);  // 传FLAG_ONE和FLAG_TWO
    parse_flags(FLAG_ONE | FLAG_TWO | FLAG_THREE);  // 传所有标志
    parse_flags(0);  // 不传任何标志
    return 0;
}

编译运行：

bash 复制代码 
gcc -o flags_demo flags_demo.c
./flags_demo
# 输出：
# 标志位包含 FLAG_ONE
# ------------------------
# 标志位包含 FLAG_ONE
# 标志位包含 FLAG_TWO
# ------------------------
# 标志位包含 FLAG_ONE
# 标志位包含 FLAG_TWO
# 标志位包含 FLAG_THREE
# ------------------------
# ------------------------

这种方式的优点是高效、灵活，能通过一个整数传递多个独立的选项，这也是系统调用中标志位传递的标准方式。

3.2 系统调用写文件：open 与 write 的使用

C 库的fopen对应系统调用的open，fwrite对应write。下面我们用系统调用实现与 2.2 节相同的写文件功能。

实战代码：系统调用写文件

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    // 1. 关闭默认的文件创建掩码（确保文件权限按我们指定的设置）
    umask(0);
    
    // 2. 调用open系统调用打开/创建文件
    // O_WRONLY：只写模式；O_CREAT：文件不存在则创建；0644：文件权限
    int fd = open("myfile_sys", O_WRONLY | O_CREAT, 0644);
    if (fd < 0) {  // 系统调用失败返回-1
        perror("open error");  // perror打印系统调用错误信息
        return 1;
    }
    printf("open success, fd = %d\n", fd);  // 打印文件描述符
    
    // 3. 调用write系统调用写入数据
    const char *msg = "hello bit (syscall)!\n";
    int len = strlen(msg);
    int count = 5;
    while (count--) {
        // fd：文件描述符；msg：缓冲区；len：要写入的字节数
        ssize_t ret = write(fd, msg, len);
        if (ret < 0) {
            perror("write error");
            break;
        }
        printf("写入 %zd 字节\n", ret);
    }
    
    // 4. 调用close系统调用关闭文件
    close(fd);
    return 0;
}

编译运行：

bash 复制代码 
gcc -o write_sys write_sys.c
./write_sys
# 输出：
# open success, fd = 3
# 写入 18 字节
# 写入 18 字节
# 写入 18 字节
# 写入 18 字节
# 写入 18 字节
cat myfile_sys  # 查看写入的内容

3.3 系统调用读文件：read 的使用

对应的，我们用open（只读模式）和read系统调用实现文件读取功能。

实战代码：系统调用读文件

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    // 1. 以只读模式打开文件
    int fd = open("myfile_sys", O_RDONLY);
    if (fd < 0) {
        perror("open error");
        return 1;
    }
    printf("open success, fd = %d\n", fd);
    
    // 2. 调用read系统调用读取数据
    const char *msg = "hello bit (syscall)!\n";
    int msg_len = strlen(msg);
    char buf[1024];
    while (1) {
        // 每次读取msg_len个字节
        ssize_t ret = read(fd, buf, msg_len);
        if (ret > 0) {  // 成功读取到数据
            buf[ret] = '\0';
            printf("%s", buf);
        } else if (ret == 0) {  // 到达文件末尾
            printf("文件读取完毕\n");
            break;
        } else {  // 读取错误
            perror("read error");
            break;
        }
    }
    
    // 3. 关闭文件
    close(fd);
    return 0;
}

编译运行：

bash 复制代码 
gcc -o read_sys read_sys.c
./read_sys
# 输出结果与myfile_sys内容一致

3.4 系统文件 IO 接口详解

上面我们用到了**open、write、read、close**四个核心系统调用，下面详细介绍它们的函数原型、参数含义和返回值。

（1） open 系统调用：打开或创建文件

open是最核心的系统调用之一，用于打开或创建文件，函数原型有两个：

cpp 复制代码 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

// 方式1：打开已存在的文件
int open(const char *pathname, int flags);

// 方式2：创建新文件（或打开已存在文件）
int open(const char *pathname, int flags, mode_t mode);
参数说明：
  • pathname：文件路径（相对路径或绝对路径）；
  • flags：打开文件的标志位，必须包含以下三个之一（读写权限）：
    • O_RDONLY：只读打开；
    • O_WRONLY：只写打开；
    • O_RDWR：读写打开；还可以搭配以下可选标志：
    • O_CREAT：文件不存在则创建（必须使用三个参数的open）；
    • O_TRUNC：文件存在则截断为 0 长度（清空内容）；
    • O_APPEND：追加写（写指针位于文件末尾）；
    • O_EXCL：与O_CREAT搭配使用，若文件已存在则open失败；
  • mode：文件权限（仅当flags包含O_CREAT时有效），如0644、0755等。
返回值：
  • 成功：返回一个非负整数，即文件描述符（File Descriptor，简称 fd）；
  • 失败：返回-1，并设置errno（错误码），可通过perror函数打印错误信息。

（2） write 系统调用：向文件写入数据

cpp 复制代码 
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
参数说明：
  • fd：文件描述符（open的返回值）；
  • buf：指向要写入数据的缓冲区指针；
  • count：期望写入的字节数；
返回值：
  • 成功：返回实际写入的字节数（可能小于count，如磁盘空间不足）；
  • 失败：返回-1，并设置errno。

（3） read 系统调用：从文件读取数据

cpp 复制代码 
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
参数说明：
  • fd：文件描述符；
  • buf：指向存储读取数据的缓冲区指针；
  • count：期望读取的字节数；
返回值：
  • 成功：返回实际读取的字节数；
  • 到达文件末尾：返回0；
  • 失败：返回-1，并设置errno。

（4） close 系统调用：关闭文件

cpp 复制代码 
#include <unistd.h>

int close(int fd);
参数说明：
  • fd：文件描述符；
返回值：
  • 成功：返回0；
  • 失败：返回-1，并设置errno。

3.5 open 函数返回值：文件描述符的本质

open系统调用成功后返回的文件描述符（fd），是理解 Linux 文件 IO 的核心概念。很多初学者会疑惑：为什么返回的是一个小整数（如 3、4）？这个整数到底代表什么？

（1） 文件描述符的定义：数组的下标

文件描述符是一个非负整数，本质上是进程打开文件表（files_struct）中文件指针数组（fd_array）的下标。

每个进程都有一个task_struct（进程控制块），其中包含一个指向files_struct结构体的指针，files_struct中最重要的成员是fd_array------ 一个指向file结构体的指针数组。

file结构体是内核用来描述一个打开文件的元数据（如文件路径、权限、读写位置、文件操作函数指针等）。当进程调用open系统调用时，内核会：

  1. 检查文件是否存在，权限是否允许；
  2. 创建一个file结构体，存储该文件的元数据；
  3. 在fd_array中找到一个未使用的最小下标；
  4. 将file结构体的指针存入该下标对应的位置；
  5. 返回这个下标作为文件描述符。

简单来说：文件描述符 = fd_array 数组的下标 ，通过这个下标，进程可以快速找到对应的file结构体，从而操作文件。

（2） 默认打开的三个文件描述符

前面提到，C 程序启动时会默认打开三个标准流（stdin、stdout、stderr），对应的文件描述符分别是：

  • 0：标准输入（stdin），对应键盘；
  • 1：标准输出（stdout），对应显示器；
  • 2：标准错误（stderr），对应显示器。

这意味着，进程启动时，**fd_array[0]、fd_array[1]、fd_array[2]**已经被占用，分别指向键盘、显示器、显示器的file结构体。因此，我们新打开的第一个文件，其文件描述符会是3（最小的未使用下标）。

实战验证：文件描述符的分配规则

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 新打开一个文件，查看fd
    int fd1 = open("test1.txt", O_RDWR | O_CREAT, 0644);
    printf("fd1 = %d\n", fd1);  // 输出3
    
    // 再打开一个文件
    int fd2 = open("test2.txt", O_RDWR | O_CREAT, 0644);
    printf("fd2 = %d\n", fd2);  // 输出4
    
    // 关闭fd1
    close(fd1);
    
    // 再打开一个文件，会复用fd1的下标（3）
    int fd3 = open("test3.txt", O_RDWR | O_CREAT, 0644);
    printf("fd3 = %d\n", fd3);  // 输出3
    
    close(fd2);
    close(fd3);
    return 0;
}

编译运行：

cpp 复制代码 
gcc -o fd_demo fd_demo.c
./fd_demo
# 输出：
# fd1 = 3
# fd2 = 4
# fd3 = 3

这验证了文件描述符的分配规则：在 fd_array 数组中，找到当前未使用的最小下标作为新的文件描述符。

（3） 库函数与系统调用的关系

通过文件描述符的本质，我们可以理解 C 库函数与系统调用的关系：

  • C 库的FILE结构体内部封装了文件描述符（_fileno成员）；
  • 库函数（如fwrite）的底层的是调用系统调用（如write），并在用户层添加了缓冲区等功能；
  • 系统调用是内核提供的底层接口，库函数是对系统调用的封装，方便用户使用。

比如FILE结构体的简化定义（位于/usr/include/libio.h）：

cpp 复制代码 
struct _IO_FILE {
    int _fileno;  // 封装的文件描述符
    char *_IO_buf_base;  // 缓冲区起始地址
    char *_IO_buf_end;  // 缓冲区结束地址
    // 其他成员...
};

可以看到，_fileno就是FILE结构体封装的文件描述符，库函数的所有操作最终都会通过这个文件描述符调用系统调用。

总结

掌握这些知识点后，你对 Linux 文件 IO 的理解就不再停留在 "会用" 的层面，而是能够深入底层原理，解决更复杂的问题（如重定向、缓冲区优化、自定义 IO 库等）。

后续我们还会深入学习文件 IO 的高级特性，比如重定向、内核缓冲区、IO 多路复用等，敬请期待！如果本文对你有帮助，欢迎点赞、收藏、转发，也欢迎在评论区交流讨论～

相关推荐
杜子不疼.4 小时前
【Linux】基础IO（二）：系统文件IO
linux·运维·服务器
郝学胜-神的一滴4 小时前
深入理解网络IP协议与TTL机制：从原理到实践
linux·服务器·开发语言·网络·网络协议·tcp/ip·程序人生
松涛和鸣4 小时前
DAY61 IMX6ULL UART Serial Communication Practice
linux·服务器·网络·arm开发·数据库·驱动开发
Justice link12 小时前
K8S基本配置
运维·docker·容器
观熵12 小时前
SaaS 系统的自动化部署结构设计实战指南：基于 K8s + Helm 的工程落地路径
运维·kubernetes·自动化·saas 架构
chinesegf12 小时前
ubuntu中虚拟环境的简单创建和管理
linux·运维·ubuntu
若涵的理解12 小时前
一文读懂K8S kubectl 命令，运维小白必看！
运维·docker·kubernetes
java_logo12 小时前
2025 年 11 月最新 Docker 镜像源加速列表与使用指南
linux·运维·docker·容器·运维开发·kylin
一碗面42112 小时前
Linux下的网络模型
linux·网络模型
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04UV安装并设置国内源05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06BongoCat - 跨平台键盘猫动画工具07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南09Linux下V2Ray安装配置指南10Open Code教程（四）| 高级配置与集成