022 基础 IO —— 文件

🦄 个人主页: 小米里的大麦-CSDN博客
🎏 所属专栏: Linux_小米里的大麦的博客-CSDN博客
🎁 GitHub主页: 小米里的大麦的 GitHub
⚙️ 操作环境: Visual Studio 2022

基础 IO —— C 语言文件 I/O 操作基础

前言

1. 文件的基本概念

文件的定义：

• 文件 = 内容（数据） + 属性（如权限、修改时间、所有者等）。
• 属性是文件管理的重要依据，贯穿文件的存储、访问和控制全流程。

2. 文件的两种状态

1. 打开的文件

   • 触发条件：由进程主动打开（如读写操作）。
   • 存储位置：加载到内存中。
   • 核心机制：
     • 进程关联：每个打开的文件需与进程绑定，形成“进程-文件”的 多对一关系（1: n 关系：一个进程可打开多个文件）。
     • 内核管理：操作系统为每个打开的文件创建 文件打开对象（如 struct XXX），记录文件属性、状态及链表指针（如 next），便于统一管理。

2. 未打开的文件

   • 存储位置：磁盘上。
   • 核心问题：如何高效组织海量未打开文件，支持 快速增删查改。
   • 管理目标：通过目录结构、文件系统层级等实现文件分类与定位。

3. 操作系统如何管理打开的文件

1. 管理原则 —— 先描述，后组织：

   • 描述：为每个打开的文件创建内核对象（如 struct file），记录文件属性（如读写位置、权限）和操作接口。
   • 组织：通过链表、哈希表等数据结构管理所有打开的文件对象，实现高效访问。

2. 关键数据结构示例

   struct file
   {mode_t permissions;    // 文件权限off_t read_offset;     // 当前读位置struct inode *inode;   // 指向磁盘文件的元数据（如 inode）struct file *next;     // 链表指针，用于组织多个打开的文件
   };
   

3. 核心目标

   • 高效管理大量打开的文件。
   • 确保进程间文件操作的隔离性与安全性（如通过文件描述符隔离）。

1. C 语言文件操作函数汇总

CSDN 相关文章

1. 文件打开与关闭

函数	参数与模式	返回值	功能描述	示例
fopen	(const char *filename, const char *mode) 模式："r"（读）、"w"（写覆盖）、"a"（追加）、"rb"（二进制读）等	FILE*（成功） NULL（失败）	打开文件并返回文件指针	FILE *fp = fopen("test.txt", "r");
fclose	(FILE *stream)	0（成功） EOF（失败）	关闭文件流并释放资源	fclose(fp);
freopen	(const char *filename, const char *mode, FILE *stream)	FILE*（新流） NULL（失败）	重定向已打开的流到新文件	freopen("log.txt", "a", stdout);

2. 字符与字符串读写

函数	参数与说明	返回值	功能描述	注意事项
fputc	(int char, FILE *stream)	写入的字符（成功） EOF（失败）	向文件写入一个字符	适用于文本文件
fgetc	(FILE *stream)	读取的字符（成功） EOF（失败或结尾）	从文件读取一个字符	需用 feof 检测结尾
fputs	(const char *str, FILE *stream)	非负值（成功） EOF（失败）	向文件写入字符串（不自动加 \n）	确保字符串以 \0 结尾
fgets	(char *str, int n, FILE *stream)	str（成功） NULL（失败或结尾）	从文件读取一行字符串（最多 n-1 字符）	保留换行符，末尾补 \0

3. 格式化读写

函数	参数与格式说明	返回值	功能描述	示例
fprintf	(FILE *stream, const char *format, ...)	写入的字符数（成功） 负值（失败）	按格式向文件写入数据	fprintf(fp, "Value: %d", 42);
fscanf	(FILE *stream, const char *format, ...)	成功匹配的参数数量（成功） EOF（失败）	按格式从文件读取数据	fscanf(fp, "%d", &num);

4. 二进制文件读写

函数	参数与说明	返回值	功能描述	注意事项
fwrite	(const void *ptr, size_t size, size_t count, FILE *stream)	成功写入的项数	向二进制文件写入数据块	参数顺序：数据指针、项大小、项数量
fread	(void *ptr, size_t size, size_t count, FILE *stream)	成功读取的项数	从二进制文件读取数据块	需检查返回值以确认实际读取量

5. 文件定位与状态

函数	参数与说明	返回值	功能描述	示例
fseek	(FILE *stream, long offset, int origin) origin：SEEK_SET（文件头）、SEEK_CUR（当前位置）、SEEK_END（文件尾）	0（成功） 非零（失败）	移动文件指针到指定位置	fseek(fp, 10, SEEK_SET);
ftell	(FILE *stream)	当前偏移量（成功） -1L（失败）	获取文件指针当前位置	long pos = ftell(fp);
rewind	(FILE *stream)	无	重置文件指针到文件开头	rewind(fp);
feof	(FILE *stream)	非零值（到结尾） 0（未到结尾）	检测文件指针是否到达结尾	if (feof(fp)) { ... }
ferror	(FILE *stream)	非零值（有错误） 0（无错误）	检测文件操作是否出错	if (ferror(fp)) { ... }

6. 其他辅助函数

函数	参数与说明	返回值	功能描述	示例
fflush	(FILE *stream)	0（成功） EOF（失败）	强制将缓冲区数据写入文件	fflush(fp);
remove	(const char *filename)	0（成功） 非零（失败）	删除指定文件	remove("temp.txt");
rename	(const char *oldname, const char *newname)	0（成功） 非零（失败）	重命名或移动文件	rename("old.txt", "new.txt");

2. 什么是当前路径？

#include <stdio.h>
#include <unistd.h>
int main()
{FILE* fp = fopen("temp.txt", "w");		// 打开文件，如果文件不存在则创建，如果存在则覆盖if (fp == NULL){perror(" fopen");					// 如果打开文件失败，打印错误信息return 1;}fclose(fp);								// 关闭文件sleep(1);								// 休眠 1 秒return 0;
}

由上我们知道，当 fopen 以写入的方式打开一个文件时，若该文件不存在，则会自动在当前路径创建该文件，那么这里所说的当前路径指的是什么呢？答案是 进程的当前路径——cwd。验证：

#include <stdio.h>
#include <unistd.h>
int main()
{chdir("/home/hcc");						// 改变当前工作目录为/home/hcc(注意：目录不存在，可能会导致后续操作失败)printf("Pid: %d\n", getpid());          // 打印进程 IDFILE* fp = fopen("temp.txt", "w");      // 打开文件，如果文件不存在则创建，如果存在则覆盖if (fp == NULL){perror(" fopen");		            // 如果打开文件失败，打印错误信息return 1;}fclose(fp);				                // 关闭文件sleep(100);			                    // 休眠 100 秒return 0;
}

3. w 总是先清空，再写入

fopen 的 w 模式，当以 w 模式打开文件时：

• 如果文件不存在，则创建新文件。
• 如果文件已存在，则清空原有内容并重新开始写入。

#include <stdio.h>
#include <unistd.h>         // 包含系统调用的头文件，如 getpid 等
#include <string.h>         // 包含字符串处理函数的头文件，如 strlen 等int main()
{printf("Pid: %d\n", getpid());// 打开文件 temp.txt，模式为 "w"，表示以写方式打开文件// 如果文件不存在，则创建该文件// 如果文件已存在，则覆盖原有内容FILE* fp = fopen("temp.txt", "w");if (fp == NULL){perror("fopen");return 1;}const char* message = "abcd";       // 定义一个字符串常量 message，字符串常量是只读的，不能被修改// 将字符串 message 写入文件// fwrite 函数用于将数据写入文件// 第一个参数是要写入的数据的指针// 第二个参数是每个数据单元的大小，这里是 1 字节（即每个字符）// 第三个参数是数据单元的数量，这里是字符串的长度加 1（包括字符串结束符'\0'）// 第四个参数是文件指针fwrite(message, strlen(message) + 1, 1, fp);fclose(fp);                         // 关闭文件return 0;
}

好像没什么问题，w 会先清空文件，再将新文件内容进行写入，但是当我们打开这个 temp.txt 文件就会发现一点问题：

注意：w 即使不写入数据，只打开文件也会清空文件数据！ 因为 w 是先清空再写入。

echo 与 fopen 的关系

• 底层实现：echo 是 shell 命令，但其重定向功能依赖于操作系统提供的文件 I/O 机制。
• 类比 fopen("w")：当执行 echo ... > file 时，系统调用类似 fopen(file, "w") 的操作，确保输出内容替换原有数据。

虽然 echo 本身不直接调用 fopen，但其重定向功能在底层实现了与 fopen("w") 相同的效果：覆盖原有文件内容。因此，可以认为 echo 的重定向机制在功能上模拟了 fopen 的 w 模式。

echo "现在有文件数据哦！" > temp.txt			# 创建初始文件
echo "你好！" > temp.txt						# 使用 echo 覆盖内容
cat temp.txt								# 查看结果结果显示：temp.txt的内容被完全替换为“你好！”，证明echo的重定向行为等同于fopen的w模式。

4. a 是追加写

特性	说明
追加模式	写入内容总在文件末尾，不覆盖原有数据。
自动创建文件	若文件不存在，a 模式会创建新文件。
文本模式 vs 二进制	默认为文本模式（"a"），若需二进制追加，使用 "ab"。
缓冲区依赖	写入内容需等待缓冲区满或显式刷新（fflush）后才写入磁盘。

1. 基本追加写入

#include <stdio.h>
int main()
{FILE* file = fopen("log.txt", "a");             // 以追加模式打开文件if (file == NULL){perror("打开文件失败");return 1;}fprintf(file, "这是一个测试文件\n");             // 写入内容到文件末尾fclose(file);                                  // 关闭文件return 0;
}

特性说明

• 追加行为：每次写入均追加到文件末尾，不覆盖原有内容。
• 自动创建：若文件不存在，a 模式会自动创建新文件。

2. 文件不存在时的自动创建

#include <stdio.h>
int main()
{FILE* file = fopen("file.txt", "a");    // 文件不存在时自动创建if (file == NULL){perror("写入文件失败");return 1;}fprintf(file, "已创建并追加的文件。\n");fclose(file);return 0;
}

特性说明

• 权限问题：若当前目录无写权限，a 模式会失败（需处理 fopen 返回的 NULL）。

3. 未关闭文件导致的数据丢失

#include <stdio.h>
int main()
{FILE* file = fopen("data.txt", "a");if (file == NULL){perror("Error");return 1;}fprintf(file, "重要数据！");  // 写入后未关闭文件// 错误：未调用 fclose(file)return 0;
}

坑点说明

• 未关闭文件：若程序异常终止或忘记调用 fclose，缓冲区中的数据可能未写入磁盘。
• 解决方案：始终确保写入后调用 fclose，或显式调用 fflush(file) 强制刷新缓冲区。

4. 并发写入的潜在问题

#include <stdio.h>
int main()
{FILE* file1 = fopen("shared.txt", "a");FILE* file2 = fopen("shared.txt", "a");  // 同一文件被多次打开fprintf(file1, "来自 file1 的消息\n");fprintf(file2, "来自 file2 的消息\n");fclose(file1);fclose(file2);return 0;
}

坑点说明

• 并发写入：若多个进程/线程同时追加文件，内容可能交错（如 "来自 file2 的消息\n"）。
• 解决方案：在多线程/多进程场景中，需通过锁机制或原子操作保证顺序。

---

5. open() 函数

题外话：比特位方式的标志位传递。其核心原理是通过 二进制位的每一位 来表示不同的标志状态，利用位运算符（如 | 和 &）高效地组合和检测多个标志（了解，以后详解）。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>#define ONE (1<<0)                                          // 0001 -> 十进制 1
#define TWO (1<<1)                                          // 0010 -> 十进制 2
#define THREE (1<<2)                                        // 0100 -> 十进制 4
#define FOUR (1<<3)                                         // 1000 -> 十进制 8void show(int flags)
{if(flags&ONE) printf("hello function1\n");              // 如果第 0 位是 1if(flags&TWO) printf("hello function2\n");              // 如果第 1 位是 1if(flags&THREE) printf("hello function3\n");            // 如果第 2 位是 1if(flags&FOUR) printf("hello function4\n");             // 如果第 3 位是 1
}int main()
{printf("-----------------------------\n");show(ONE);printf("-----------------------------\n");show(TWO);printf("-----------------------------\n");show(ONE|TWO);printf("-----------------------------\n");show(ONE|TWO|THREE);printf("-----------------------------\n");show(ONE|THREE);printf("-----------------------------\n");show(THREE|FOUR);printf("-----------------------------\n");
}

---

open() 是 Linux 系统调用中最核心、最常用的函数之一，是一切文件/设备操作的起点。

1. 头文件

#include <fcntl.h>      // 提供 open 函数、O_RDONLY 等常量
#include <sys/types.h>
#include <sys/stat.h>

2. 函数原型 & 参数解释

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);  // 创建文件时用到

3. 参数说明

参数	说明
pathname	文件路径（绝对或相对路径）
flags	文件打开方式和行为控制（重点！）
mode	权限位（只有当创建新文件时才用！）

4. 返回值

返回值	含义
>= 0	打开成功，返回的是 文件描述符（整数）
< 0	打开失败，返回 -1，具体错误原因通过 errno 查看

if (fd < 0)
{perror("open failed");
}

---

1. flags 参数详解（支持“位或 |”组合使用）

1. 访问方式（必须选一个）

常量	说明
O_RDONLY	只读打开（Read Only）
O_WRONLY	只写打开（Write Only）
O_RDWR	读写都打开（Read + Write）

2. 控制行为（可选，多个之间用 | 连接）

常量	含义
O_CREAT	文件不存在就创建（需要配合 mode 参数）
O_EXCL	和 O_CREAT 同用，文件存在则失败（避免重复创建）
O_TRUNC	打开文件时清空原内容（通常配合写）
O_APPEND	写入内容追加到文件末尾
O_NONBLOCK	非阻塞模式打开文件（常用于设备/管道）
O_CLOEXEC	在 exec 调用时关闭该文件描述符
O_SYNC	写入时直接同步到硬盘（安全但慢）

2. mode 参数（仅在 O_CREAT 创建新文件时才用）

open("file.txt", O_WRONLY | O_CREAT, 0664);

• mode_t 用来设置 新文件的权限，与 chmod 类似
• 常用组合：

权限数字	含义说明
0664	用户读写，组读写，其他只读
0644	用户读写，其他只读

代码示例解读：

// 代码 1：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main()
{int fd = open("temp.txt", O_WRONLY);if (fd < 0){printf("open file error\n");return 1;}return 0;
}// 代码 2：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main()
{int fd = open("temp.txt", O_WRONLY | O_CREAT);if (fd < 0){printf("open file error\n");return 1;}return 0;
}// 代码 3：头文件一样，后面不再重复
int main()
{int fd = open("temp.txt", O_WRONLY | O_CREAT, 0666);if (fd < 0){printf("open file error\n");return 1;}return 0;
}// 代码 4：
int main()
{umask(0);int fd = open("temp.txt", O_WRONLY | O_CREAT, 0666);if (fd < 0){printf("open file error\n");return 1;}return 0;
}

代码编号	是否自动创建文件	权限设定	是否受 umask 影响	常见用途
1️⃣	❌ 否	无	-	仅打开已存在文件
2️⃣	⚠️ 可能报错	❌ 缺少权限参数（可能是乱码）	-	不推荐用法
3️⃣	✅ 创建	0666 - umask（与 0666 不符，原因 umask）	✅ 是	正常用法
4️⃣	✅ 创建	0666	❌ 不受影响	特殊场合

---

3. 战代码示例：打开 + 写入 + 关闭

#include <fcntl.h>                      // 包含文件控制相关的定义和函数声明
#include <unistd.h>                     // 包含 POSIX 操作函数的声明，如 open、close、write 等
#include <stdio.h>                      // 包含标准输入输出函数的声明，如 perror 等
int main()
{// 打开或创建文件，并设置为只写模式、创建文件、截断文件int fd = open("demo.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);if (fd < 0){perror("open failed");          // 打印错误信息，open failed 为自定义的错误前缀return 1;                       // 打开文件失败，返回非零值表示程序异常退出}const char* msg = "实习 / 工作要掌握 open 的实战用法！\n";       // 定义要写入文件的字符串，将字符串写入文件write(fd, msg, strlen(msg));        // 第一个参数是文件描述符，第二个是数据的指针，第三个是数据的长度close(fd);                          // 关闭文件，释放资源return 0;                           // 程序正常退出
}

6. 文件描述符

先出结论：open() 的返回值 就是文件描述符（fd），它是一个 数组下标，指向当前进程的 打开文件表（fd table） 中的一个 struct file * 指针。

int fd = open("a.txt", O_WRONLY);  // 返回 3
write(fd, "Hello", 5);             // 实际就是 write(fd_table [3], ...)

我们通过一段完整的 C 代码 演示：“访问文件的本质，其实是 数组下标访问”。接着再来讲解内核中是如何通过 struct file、struct files_struct 等结构体来描述和管理已打开的文件。

1. C 代码示例：文件描述符本质是数组下标

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>int main()
{// 打开三个不同的文件int fd1 = open("file1.txt", O_CREAT | O_WRONLY, 0666);int fd2 = open("file2.txt", O_CREAT | O_WRONLY, 0666);int fd3 = open("file3.txt", O_CREAT | O_WRONLY, 0666);if (fd1 < 0 || fd2 < 0 || fd3 < 0){perror("open");return 1;}printf("fd1: %d\n", fd1);  // 通常是 3printf("fd2: %d\n", fd2);  // 通常是 4printf("fd3: %d\n", fd3);  // 通常是 5write(fd2, "Hello file2\n", 12);  // 通过 fd2 向 file2.txt 写入内容close(fd1);close(fd2);close(fd3);return 0;
}

输出示例（实际运行）：

fd1: 3
fd2: 4
fd3: 5

解释说明：

为什么编号是从 3 开始的？0，1，2 去哪了？

答案：Linux 进程默认情况下会有 3 个缺省打开的文件描述符，分别是标准输入 0，标准输出 1，标准错误 2。0，1，2 对应的物理设备一般是：键盘，显示器，显示器。

• 标准输入（stdin）：文件描述符是 0
• 标准输出（stdout）：是 1
• 标准错误（stderr）：是 2

后续打开的文件就是从 下标 3 开始往上分配。所以：fd 本质上是一个 打开文件表的下标（int 类型的索引）

---

2. 内核层的结构体解析（推荐 linux-2.6.11.1.tar.gz —— 09-Mar-2005 00:59 44M 这个版本查看源码）

用户层调用 open() 后，内核做了什么？

Linux 内核有三层数据结构来描述一个打开的文件：

1. files_struct（表示进程级的打开文件表）

struct files_struct
{struct file *fd_array[NR_OPEN];  // 进程文件描述符数组（最多可打开的文件数）
};

• 每个进程都有一个 files_struct 实例。
• fd_array[i] 中存的是指向 struct file 的指针。
• 这个数组的下标就是我们用户层看到的 fd！

2. struct file（表示一个已打开的文件实例）

struct file
{struct inode *f_inode;          // 指向文件的 inode 结构loff_t        f_pos;            // 当前读写位置（文件偏移量）struct file_operations *f_op;   // 操作函数表...
};

• 表示一次文件打开操作。
• 不同进程打开同一个文件，会有 不同的 struct file。
• struct file 直接或间接包含的属性：在磁盘的什么位置、基本属性（权限、大小、读写位置、谁打开的……）、文件的内核缓冲区信息、struct file *next 指针、引用计数 count 等。
• 类似于“文件打开上下文”，记录偏移、标志等状态。

3. inode（文件元数据结构）

struct inode
{// 文件类型、权限、拥有者、指向数据块的指针等等
};

• 一个 inode 代表文件系统中一个“实际的文件”。
• 所有打开该文件的 file 都指向同一个 inode。

3. 三者之间的联系总结

小结：用户空间的文件描述符（fd）就是内核中的 struct file * 数组的下标！通过这个下标，进程就能访问并操作该文件在内核中对应的资源。

4. 文件描述符的分配规则

先出结论：Linux 内核始终分配当前未被使用的最小下标，作为新的文件描述符。当你调用 open() 或 dup() 等函数时，内核会在 fd_array[] 中从头开始查找：寻找当前未被使用的最小下标，作为新的文件描述符（fd）。

关闭 fd 后： 它会被回收，下一次打开文件就可能重复使用这个编号。

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>int main()
{close(0);                           // 关闭标准输入（fd = 0）int fd1 = open("test1.txt", O_CREAT | O_RDWR, 0666);printf("fd1=%d\n", fd1);            // 输出 fd1 = 0close(1);                           // 关闭标准输出（fd = 1）int fd2 = open("test2.txt", O_CREAT | O_RDWR, 0666);printf("fd2=%d\n", fd2);            // 无法输出到终端（因为 stdout 已关闭），重定向到文件观察close(2);                           // 关闭标准错误（fd = 2）int fd3 = open("test3.txt", O_CREAT | O_RDWR, 0666);printf("fd3=%d\n", fd3);            // 同样无法输出到终端return 0;
}

运行与验证:

1. 编译并运行程序，将输出重定向到文件：

   gcc test.c -o test && ./test > output.txt 2>&1
   

2. 查看 output.txt：

   fd1=0
   fd2=1
   fd3=2
   

说明：关闭 0/1/2 后，新打开的文件的描述符依次复用这些最小下标。

---

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
// dprintf(fd, ...) 就是“向 fd 指定的地方 像用 printf 一样 输出内容”，非常适合标准输出关闭或重定向时使用。
int main()
{printf("原始状态：stdin=0, stdout=1, stderr=2\n");       // 先确认 fd = 0,1,2 都是开启状态close(1);                                               // 关闭标准输出（fd = 1），但保留 stdin(0) 和 stderr(2)int fd1 = open("test1.txt", O_CREAT | O_RDWR, 0666);    // 打开文件 1dprintf(2, "fd1 = %d\n", fd1);                          // 输出到 stderr（fd = 2），应为 1close(0);                                               // 关闭标准输入（fd = 0）int fd2 = open("test2.txt", O_CREAT | O_RDWR, 0666);    // 打开文件 2dprintf(2, "fd2 = %d\n", fd2);                          // 应为 0int fd3 = open("test3.txt", O_CREAT | O_RDWR, 0666);    // 打开文件 3（fd = 2 还在用）dprintf(2, "fd3 = %d\n", fd3);                          // 应为 3，因为 0 和 1 被占用，新开只能用 3return 0;
}

输出内容会写入 stderr（fd = 2），因为 stdout 被关闭。示例输出：

fd1 = 1  ← 因为 fd=1 被关闭，最小空位就是 1
fd2 = 0  ← fd=0 被关闭，最小空位变为 0
fd3 = 3  ← 此时 0 和 1 被占用，2 还在用，所以下一空位是 3

注意： 当你只关闭了 fd=1，而 0 和 2 保持开启，新文件会被分配到 1。不会跳到 2，因为 2 是正在使用中的文件描述符（stderr）。所以：

• 内核分配新 fd 的顺序是：从低到高，找第一个没用的。
• 如果你关闭了某个 fd，那么它会被下一次 open() 回收复用。
• 只有当 0、1、2 都被关闭，才会让新文件从 0 开始重新分配。

---

7. 文件描述符 VS FILE *

一句话总结：文件描述符（fd） 是 Linux 系统内核的低层 I/O 机制，而 FILE \* 是 C 标准库（stdio.h）封装的高级 I/O 结构，它内部依赖文件描述符实现功能。

1. 文件描述符（int fd）

• 是 Linux 内核分配的一个 整数索引
• 用于标识当前进程打开的某个文件（实际上是指向内核 struct file 的下标）
• 使用 open(), read(), write(), close() 等系统调用操作
• 属于 低级 I/O

示例：

int fd = open("a.txt", O_RDWR);			// 打开文件 "a.txt"，以读写模式（O_RDWR）打开，返回文件描述符 fd
write(fd, "hello", 5);					// 向文件描述符 fd 指向的文件中写入字符串 "hello"，写入长度为 5 字节
close(fd);								// 关闭文件描述符 fd，释放相关资源

2. FILE * 指针

• 是 stdio.h 定义的 高级抽象结构体
• 内部其实就是封装了一个 int fd + 缓冲区 + 文件状态等信息
• 使用 fopen(), fread(), fwrite(), fprintf(), fclose() 等函数操作
• 属于 高级 I/O

示例：

FILE* fp = fopen("a.txt", "w");			// 以写模式（"w"）打开文件 "a.txt"，返回文件指针 fp，注意：以 "w" 模式打开会清空文件原有内容
fprintf(fp, "hello\n");					// 使用 fprintf 向文件指针 fp 指向的文件中写入字符串 "hello\n"
fclose(fp);								// 关闭文件指针 fp，确保数据被正确写入并释放相关资源

3. 二者之间的关系图

FILE *fp ───► struct __FILE (库层) ───► int fd ───► 内核打开文件表（files_struct）

4. 相互转换方法

从 FILE * 获取 fd：

int fd = fileno(fp);

从 fd 获取 FILE *：

FILE *fp = fdopen(fd, "w");

5. 区别对比总结

特性	文件描述符（int fd）	FILE * 指针
所属层次	内核层（系统调用）	C 标准库（用户空间）
使用头文件	<fcntl.h>, <unistd.h>	<stdio.h>
是否有缓冲机制	❌ 无缓冲	✅ 有缓冲
速度	快（系统级）	慢（用户态带缓冲）
函数接口	open/read/write	fopen/fread/fwrite
可否转换	✅ 可以互相转换	✅ 可以互相转换
控制精细程度	更细粒度（如非阻塞、异步）	比较抽象、功能丰富

实战建议：

场景	建议使用
写系统调用、驱动、IO 重定向等底层功能	fd（文件描述符）
做格式化文本输出、文件读写、缓存优化等	FILE *（标准库）

共勉