文件被加载之前，被存在磁盘上，操作文件，文件的部分内容则会被调度到 内存中。

要分析文件，我们也把文件分成两种：

• 磁盘上的文件（文件系统）
• 内存中的文件

这里谈论的是，内存中的文件

文件被打开，OS 会为被打开的文件创建对应的内核数据结构 struct file，将所有这个类型的结构体用某种数据结构链接起来以供 OS 管理。

struct file
{
	// 各种文件属性（磁盘中读出来的）
	// 各种链接关系
	// 缓冲区相关
};

---

一、系统调用接口

---

主要介绍一个

open

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

// man 手册查看
man 2 open

• int open(const char *pathname, int flags)
   
• int open(const char *pathname, int flags, mode_t mode);
   

参数 pathname：

• 文件名

参数 flags：

• 标志位，man 2 手册可查

参数 mode：

• 设置（新建）文件权限

返回值：

• 为 -1 则说明，open 失败
• 非负为 文件描述符（见后文）

参数 flags

• O_CREAT | O_WRONLY
  如果没有文件则创建生成，
  默认不会对原始文件内容做清空，会从从最开始覆盖

• O_CREAT | O_WRONLY | O_TRUNC
  如果没有文件则创建生成
  清空 写

• O_CREAT | O_WRONLY | O_APPEND
  如果没有文件则创建生成
  追加写

注意在往文件里写入的时候，strlen(str) 不要 +1，因为 ‘\0’ 是 C 语言的结束规定，不是文件的规定，加进去会乱码。

使用系统接口进行 IO 的时候，一定要注意，\0 问题

我们 C 语言使用的一系列函数

• fopen、fclose、fwrite/fputs、fread/fgets

都是系统函数的封装

• open、close、write、read

---

二、文件调用

---

1. 文件描述符 fd

任何一个进程，在启动的时候，默认都会打开三个文件：

• 标准输入 - - 设备文件 -> 键盘文件   0

• 标准输出 - - 设备文件 -> 显示器文件   1

• 标准错误 - - 设备文件 -> 显示器文件   2

    其中 标准输出 和 标准错误 都会向 显示器 打印，但他们其实是不一样的。
    eg：测试中，输入受重定向符的影响，而错误不受重定向符的影响
  

文件描述符，也是 open 对应的返回值。我们创建的文件返回的值是从 3 开始的，而 0 1 2 正是被上面默认打开的三个文件占用了。这个数字本质就是 数组下标。

一张简图：

进程中，文件描述符的分配规则：

在文件描述符表中，最小的，没有被使用的数组元素，分配给新文件

fclose(stdin);
// 等价于
close(0);

2. 文件调用原理

• 1 个进程 可以调度 n 个文件，每个文件都有 一个缓冲区
• 调用 read / write / close 这些系统接口时，都需要文件操作符。也就是说，在操作系统层面，我们必须要访问fd，才可以找到文件
• 我们所谓的 IO 类 read / write 函数，本质上是 拷贝函数
• 什么时候将缓冲区上的内容刷新到磁盘中指定的位置，由 OS 自主决定
• 进程 和 文件 并没有深度耦合，便于操作系统的管理
  

如何理解一切皆文件：

• 每个硬件都有一个 struct file 对象，C语言里面没有成员函数，使用的就是函数指针完成的众多行为。
• 进程通过 指针数组，访问的其实是这些 struct file 对象，包括里面的缓冲区、函数指针…
• 而用户的操作，实际上都是进程的操作
• 所以我们说，Linux 下，一切皆文件
  

3. FILE

#include <stdio.h>
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;

FILE *fopen(const char *path, const char *mode);

这里的 FILE * 是 结构体类型！由 C语言提供的，跟内核的 struct file 没有任何关系。

我们指定在操作系统层面，我们必须要访问 fd，才可以找到文件。也就是说 struct FILE 里面必定封装了 fd。

我们来看 FILE 源码是这样写的：

typedef struct _IO_FILE FILE; 在/usr/include/stdio.h

struct _IO_FILE {
	//...
	int _fileno; //封装的文件描述符，就是我们说的 fd
	
	// C语言维护的缓冲区相关内容
	//...
};

测试如下：

print("%d\n", stdin->_fileno);
print("%d\n", stdout->_fileno);
print("%d\n", stderr->_fileno);
FILE *fp = fopen("test.txt", "w");
print("%d\n", fp->_fileno);


--------
输出结果：
0
1
2
3

---

三、重定向

---

🌰< 输出重定向举例

close(1);
int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);	// fd = 1

printf("hello\n"); // stdout -> 1
printf("hello\n");
printf("hello\n");

---------
hello
hello
hello
字样，被保存进了 test.txt 中

🌰> 输入重定向举例

close(0);
int fd = open("test.txt", O_RDONLY);	// fd = 0

int a,b;
scanf("%d %d", &a, &b);	// stdin -> 0
printf("a = %d, b = %d\n", a, b);

---------
在 test.txt 文件中写入 123 456
运行程序后输出
a = 123， b = 456

🌰>>追加重定向举例

close(1);
int fd = open("test.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);	// fd = 1

printf("hello\n"); // stdout -> 1
printf("hello\n");
printf("hello\n");

---------
运行两次则有
hello
hello
hello
hello
hello
hello
字样，被保存进了 test.txt 中

回头看之前的问题

其中 标准输出 和 标准错误 都会向 显示器 打印，但他们其实是不一样的。
eg：测试中，输入受重定向符的影响，而错误不受重定向符的影响

原因如下：

stdout、cout -> 他们都是向 1 号文件描述符对应的文件打印；
stderr、cerr -> 他们都是向 2 号文件描述符对应的文件打印。
输出重定向时，更改的只是 1 号对应的指向，2 号未被影响。

当我们需要手动分离一个程序正确和错误信息的时候：

./a.out 1>log.txt 2>err.txt

当然也有直接的函数可以使用

dup2

头文件：

#include <unistd.h>

int dup2(int oldfd, int newfd);
 
参数 oldfd：

• 最后需要的 fd

参数 newfd：

• 需要被覆盖的 fd

相当于，把本应该到 newfd 上的，重定向到 oldfd，最后剩下的只有 oldfd

四、缓冲区

C 语言维护的 FILE 结构体 和 OS 维护的 struct file 结构体，都有自己的缓冲区（每个对象都有自己的缓冲区），这两个缓冲区是不相同的。

C库提供的刷新策略，一般有三种：

1. 无缓冲
2. 行缓冲（遇到 \n 刷新）
3. 全缓存（缓冲区满了刷新）

• 显示器采用的刷新策略：行缓冲
  普通文件采用的刷新策略：全缓冲

缓冲区的作用：节省调用者的时间

这会产生一些奇怪的现象：

// c 库
fprintf(stdout, "hello fprintf\n");
// os 系统调用
const char *msg = "hello write\n";
write(1, msg, strlen(msg));

fork();

这个程序我们在 linux 下，重定向到文件，会出现如下情况

[xxx@hostname file]$ ./a.out
hello write
hello fprintf
[xxx@hostname file]$ ./a.out > test.txt
[xxx@hostname file]$ cat test.txt
hello write
hello fprintf
hello fprintf
[xxx@hostname file]$

第一个运行容易理解，分析第二次 cat 文件内容出现的结果
原因如下：

• 首先，write 正常调用输出到显示器
• fprintf 的缓冲区，对于重定向到普通文件，使用全缓冲，这里的内容显然不能将缓冲区填满，所以进程结束时刷新
• 一直到 fork 被调用，程序还没结束，此时父子进程的缓冲区里都有一份 hello fprintf。谁先结束谁就先写诗拷贝，刷新到屏幕上，于是被打了两次

---

简易 FILE 的代码实现

---

👉🔗链接如下

---

---

🥰如果本文对你有些帮助，请给个赞或收藏，你的支持是对作者大大莫大的鼓励！！(✿◡‿◡) 欢迎评论留言~~

---