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. 文件打开与关闭

2. 字符与字符串读写

3. 格式化读写

4. 二进制文件读写

5. 文件定位与状态

6. 其他辅助函数

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());          // 打印进程 ID

    FILE* 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 是追加写

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 -> 十进制 8

void show(int flags)
{
   if(flags&ONE) printf("hello function1\n");              // 如果第 0 位是 1
   if(flags&TWO) printf("hello function2\n");              // 如果第 1 位是 1
   if(flags&THREE) printf("hello function3\n");            // 如果第 2 位是 1
   if(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. 参数说明

4. 返回值

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

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

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

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

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

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

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

代码示例解读：

// 代码 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;
}

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);  // 通常是 3
    printf("fd2: %d\n", fd2);  // 通常是 4
    printf("fd3: %d\n", fd3);  // 通常是 5

    write(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 = 0

    close(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);    // 打开文件 1
    dprintf(2, "fd1 = %d\n", fd1);                          // 输出到 stderr（fd = 2），应为 1

    close(0);                                               // 关闭标准输入（fd = 0）
    int fd2 = open("test2.txt", O_CREAT | O_RDWR, 0666);    // 打开文件 2
    dprintf(2, "fd2 = %d\n", fd2);                          // 应为 0

    int fd3 = open("test3.txt", O_CREAT | O_RDWR, 0666);    // 打开文件 3（fd = 2 还在用）
    dprintf(2, "fd3 = %d\n", fd3);                          // 应为 3，因为 0 和 1 被占用，新开只能用 3

    return 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. 区别对比总结

实战建议：

共勉