✨个人主页： 北 海
🎉所属专栏： Linux学习之旅
🎃操作环境： CentOS 7.6 阿里云远程服务器

---

---

🌇前言

文件描述符 fd 是基础IO中的重要概念，一个 fd 表示一个 file 对象，如常用的标准输入、输出、错误流的 fd 分别为 0、1、2，实际进行操作时，OS 只需要使用相应的 fd 即可，不必关心具体的 file，因此我们可以对标准流实施 重定向，使用指定的文件流，在实际 读/写 时，为了确保 IO 效率，还需要借助 缓冲区 进行批量读取，最大化提高效率。关于上述各种概念，将会在本文中详细介绍，且听我娓娓道来

---

🏙️正文

1、文件描述符

在使用 C语言 相关文件操作函数时，可以经常看到 FILE 这种类型，不同的 FILE* 表示不同的文件，实际进行读写时，根据 FILE* 进行操作即可

#include<iostream>
#include <cstdio>

using namespace std;

int main()
{
    //分别打开三个 FILE 对象
    FILE* fp1 = fopen("test1.txt", "w");
    FILE* fp2 = fopen("test2.txt", "w");
    FILE* fp3 = fopen("test3.txt", "w");

    //对不同的 FILE* 进行操作
    //……

    //关闭
    fclose(fp1);
    fclose(fp2);
    fclose(fp3);
    fp1 = fp2 = fp3 = NULL;

    return 0;
}

那么在 C语言 中，OS 是如何根据不同的 FILE* 指针，对不同的 FILE 对象进行操作的呢？

• 答案是 文件描述符 fd，这是系统层面的标识符，FILE 类型中必然包含了这个成员

如何证明呢？实践出真知，在上面代码的基础上，加入打印语句

注：stdin 等标准流在 C语言 中被覆写为 FILE 类型

//标准文件流
cout << "stdin->fd: " << stdin->_fileno << endl;
cout << "stout->fd: " << stdout->_fileno << endl;
cout << "stderr->fd: " << stderr->_fileno << endl;
cout << "===================================" << endl;
cout << "此时标准流的类型为：" << typeid(stdin).name() << endl;
cout << "此时文件流的类型为：" << typeid(fp1).name() << endl;
cout << "===================================" << endl;
//自己打开的文件流
cout << "fp1->fd: " << fp1->_fileno << endl;
cout << "fp2->fd: " << fp2->_fileno << endl;
cout << "fp3->fd: " << fp3->_fileno << endl;

可以看出，FILE 类型中确实有 fd 的存在

文件描述符 是如何设计的？新打开的文件描述符为何是从 3 开始？别急，接着往下看

1.1、先描述，再组织

操作系统是一个伟大的产物，它可以调度各种资源完成各种任务，但资源太多、任务太重，不合理的分配会导致效率低下，因此在进行设计时，必须确保 OS 操作时的高效性

比如现在学习的 文件系统，倘若不进行设计的话，在进行 IO 时，OS 必须先将所有文件扫描一遍，找到目标文件后才能进行操作，这是非常不合理的

因此，根据 先描述、再组织 原则，OS 将所有的文件都统一视为 file 对象，获取它们的 file* 指针，然后将这些指针存入指针数组中，可以进行高效的随机访问和管理，这个数组为 file* fd_array[]，而数组的下标就是神秘的 文件描述符 fd

当一个程序启动时，OS 会默认打开 标准输入、标准输出、标准错误 这三个文件流，将它们的 file* 指针依次存入 fd_array 数组中，显然，下标 0、1、2 分别就是它们的文件描述符 fd；后续再打开文件流时，新的 file* 对象会存入当前未被占用的最小下标处，所以用户自己打开的 文件描述符一般都是从 3 开始

除了文件描述符外，还需要知道文件权限、大小、路径、引用计数、挂载数等信息，将这些文件属性汇集起来，就构成了 struct files_struct 这个结构体，而它正是 task_struct 中的成员之一

1.2、files_struct

files_struct 结构体是对已打开文件进行描述后形成的结构体，其中包含了众多文件属性，本文探讨的是 文件描述符 fd

进程的 PCB 信息中必然包含文件操作相关信息，这就是 files_struct

注：文件被打开后，并不会加载至内存中（这样内存早爆了），而是静静的躺在磁盘中，等待进程与其进行 IO，而文件的 inode 可以找到文件的详细信息：所处分区、文件大小、读写权限等，关于 inode 的更多详细信息将会在 【深入理解文件系统】 中讲解

1.3、分配规则

fd 的分配规则为：先来后到，优先使用当前最小的、未被占用的 fd

存在下面两种情况：

1. 直接打开文件 file.txt，分配 fd 为 3
2. 先关闭标准输入 stdin 中原文件执行流（键盘），再打开文件 file.txt，分配 fd 为 0，因为当前 0 为最小的，且未被占用的 fd

#include<iostream>
#include <cstdio>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

using namespace std;

int main()
{
    //先打开文件 file.txt
    int fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    assert(fd != -1);   //存在打开失败的情况

    cout << "单纯打开文件 fd: " << fd << endl;

    close(fd);  //记得关闭

    //先关闭，再打开
    close(0);   //关闭1号文件执行流
    fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    cout << "先关闭1号文件执行流，再打开文件 fd: " << fd << endl;

    close(fd);

    return 0;
}

注意： 假若将标准输出 stdout 中的原文件执行流（显示器）关闭了，那么后续的打印语句将不再向显示器上打印，而是向此时 fd 为 1 的文件流中打印

//关闭 显示器 写入数据
close(1);

int fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
assert(fd != -1);   //存在打开失败的情况

cout << "单纯打开文件 fd: " << fd << endl;
cout << "you can see me! not on screen" << endl;

close(fd);  //记得关闭

这其实就是 重定向 的基本操作

1.4、一切皆文件

如何理解 Linux 中一切皆文件这个概念？

• 现象：即使是标准输入(键盘)、标准输出(显示器) 在 OS 看来，不过是一个 file 对象
• 原理：无论是硬件(外设)，还是软件(文件)，对于 OS 来说，只需要提供相应的 读方法 和 写方法 就可以对其进行驱动，打开文件流后，将 file* 存入 fd_array 中管理即可，因此在 Linux 中，一切皆文件

---

2、重定向

在学习重定向前，首先要明白 标准输入、输出、错误 的用途

• 标准输入（stdin）-> 设备文件 -> 键盘文件
• 标准输出（stdout）-> 设备文件 -> 显示器文件
• 标准错误（stderr）-> 设备文件 -> 显示器文件

标准输入：从键盘中读取数据
标准输出：将数据输出至显示器中
标准错误：将可能存在的错误信息输出至显示器中

标准输出 与 标准错误 都是向显示器中输出数据，为什么不合并为一个？

• 因为在进行排错时，可能需要单独查看错误信息，若是合并在一起，查看日志时会非常麻烦；但如果分开后，只需要将 标准错误 重定向后，即可在一个单独的文件中查看错误信息

C/C++ 中进行标准输入、输出、错误对应流：
标准输入：stdin / cin
标准输出：stdout / cout
标准错误：stderr / cerr

使用 cerr 函数可直接向标准错误流中打印信息

2.1、重定向的本质

前面说过，OS 在进行 IO 时，只会根据标准输入、输出、错误对应的文件描述符 0、1、2 来进行操作，也就是说 OS 作为上层不必关心底层中具体的文件执行流信息（fd_array[] 中存储的对象） 因此我们可以做到 “偷梁换柱”，将这三个标准流中的原文件执行流进行替换，这样就能达到重定义的目的了

2.2、利用指令重定向

下面直接在命令行中实现输出重定向，将数据输出至指定文件中，而非屏幕中

echo you can see me > file.txt

可以看到数据直接输出至文件 file.txt 中

当然也可以 从 file.txt 中读取数据，而非键盘

cat < file.txt

现在可以理解了，> 可以起到将标准输出重定向为指定文件流的效果，>> 则是追加写入
而 < 则是从指定文件流中，标准输入式的读取出数据

除此之外，我们还可以利用程序进行操作，在运行后进行重定向即可

#include <iostream>

using namespace std;

int main()
{
    cout << "标准输出 stdout" << endl;
    cerr << "标准错误 stderr" << endl;
    return 0;
}

直接运行的结果，此时的标准输出和标准错误都是向显示器上打印

利用命令行只对 标准输出 进行重定向，file.txt 中只收到了来自 标准输出 的数据，这是因为 标准输出 与 标准错误 是两个不同的 fd，现在只重定向了 标准输出 1

对 标准错误 也进行 重定向，打印内容至 file.txt

将 标准输出 打印至 file.txt 中，标准错误 打印至 log.txt 中

以上只是简单演示一下如何通过命令行进行 重定向，在实际开发中进行重定向操作时，使用的是函数 dup2

2.3、利用函数重定向

系统级接口 int dup2(int oldfd, int newfd)

函数解读：将老的 fd 重定向为新的 fd，参数1 oldfd 表示新的 fd，而 newfd 则表示老的 fd，重定向完成后，只剩下 oldfd，因为 newfd 已被覆写为 oldfd 了；如果重定向成功后，返回 newfd，失败返回 -1

参数设计比较奇怪，估计作者认为 newfd 表示重定向后，新的 fd

下面来直接使用，模拟实现报错场景，将正常信息输出至 log.normal，错误信息输出至 log.error 中

#include <iostream>
#include <cstdlib>
#include <cerrno>
#include <cassert>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

using namespace std;

int main()
{
    //打开两个目标文件
    int fdNormal = open("log.normal", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    int fdError = open("log.error", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    assert(fdNormal != -1 && fdError != -1);

    //进行重定向
    int ret = dup2(fdNormal, 1);
    assert(ret != -1);
    ret = dup2(fdError, 2);
    assert(ret != -1);

    for(int i = 10; i >= 0; i--)
        cout << i << " ";  //先打印部分信息
    cout << endl;

    int fd = open("cxk.txt", O_RDONLY); //打开不存在的文件
    if(fd == -1)
    {
        //对于可能存在的错误信息，最好使用 perror / cerr 打印，方便进行重定向
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(-1);   //退出程序
    }

    close(fd);

    return 0;
}

在开发大型项目时，将 错误信息 单独剥离出来是一件很重要的事

学习了 重定向 相关知识后，我们可以对 【简易版 bash】 进行功能更新（已于 2023.3.28 更新）

---

3、缓冲区

3.1、缓冲区存在的意义

在【基础IO】 中还存在一个重要概念：缓冲区

缓冲区 其实就是一个 buffer 数组，配合不同的刷新策略，起到提高 IO 效率的作用

感性理解：

假设你家养有一条二哈，当你在投喂食物时，如果你每次都只往嘴里丢入一粒狗粮，那么你的整个喂食过程将持续非常长的时间，这已经严重影响了你写代码的时间，你一天啥都不做，就光喂狗去了；于是你想了一个办法：给它安排了一个狗碗（缓冲区），每次都只需将狗粮倒入其中，等待它自己进食即可，这样一来不但提高了二哈的进食效率，同时也给你写代码留足了时间；类似的例子还有很多，比如如果没有垃圾桶，那么你扔的每个垃圾都得跑到垃圾站中去处理；如果货车没有货箱，那么一批货得拉好几天；如果手机没有电池，那么再高级的功能也摆脱不了充电线的桎梏

理性理解：
CPU 计算速度非常快！而磁盘的读取速度相对于 CPU 来说是非常非常慢的，因此需要先将数据写入缓冲区中，依据不同的刷新策略，将数据刷新至内核缓冲区中，供 CPU 进行使用，这样做的是目的是尽可能的提高效率，节省调用者的时间

本来 IO 就慢，如果没有缓冲区的存在，那么速度会更慢，下面通过一个代码来看看是否进行 IO 时，CPU 的算力差距

#include <iostream>
#include <unistd.h>
#include <signal.h>

using namespace std;

int count = 0;

int main()
{
    //定一个 1 秒的闹钟，查看算力
    alarm(1);   //一秒后闹钟响起
    while(true)
    {
        cout << count++ << endl;
    }
    return 0;
}

最终在 1s 内，count 累加了 10w+ 次（有 IO 的情况下）

下面改变程序，取消 IO

int count = 0;

void handler(int signo)
{
    cout << "count: " << count << endl;
    exit(1);
}

int main()
{
    //定一个 1 秒的闹钟，查看算力
    signal(14, handler);
    alarm(1);   //一秒后闹钟响起
    while(true) count++;
    
    return 0;
}

最终在没有 IO 的情况下，count 累加了 5亿+ 次，由此可以看出频繁 IO 对 CPU 计算的影响有多大，假若没有缓冲区，那么整个累加值将会更多（因为需要花费更多的时间在 IO 上）

因此在进行 读取 / 写入 操作时，常常会借助 缓冲区 buffer

#include <iostream>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

using namespace std;

int main()
{
    int fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    assert(fd != -1);

    char buffer[256] = { 0 };   //缓冲区
    int n = read(0, buffer, sizeof(buffer));    //读取信息至缓冲区中
    buffer[n] = '\0';

    //写入成功后，在写入文件中
    write(fd, buffer, strlen(buffer));

    close(fd);
    return 0;
}

3.2、缓冲区刷新策略

缓冲区有多种刷新策略，比如 C语言 中 scanf 的缓冲区刷新策略为：遇到空白字符或换行就刷新，因此在输入时需要按一下回车，缓冲区中的数据才能刷新至内核缓冲区中，而 printf 的刷新策略为 行缓冲，即遇到 \n 才会进行刷新

总体来说，缓冲区的刷新策略分为以下三种：

1. 无缓冲 -> 没有缓冲区
2. 行缓冲 -> 遇到 \n 才进行刷新，一次冲刷一行
3. 全缓冲 -> 缓冲区满了才进行刷新

一般而言，显示器的刷新策略为 行缓冲，而普通文件的刷新策略为 全缓冲

一个简单的 demo 观察 行缓冲

#include <iostream>
#include <unistd.h>

using namespace std;

int main()
{
    while(true)
    {
        //未能触发行缓冲的刷新策略，只能等缓冲区满了被迫刷新
        printf("%s", "hehehehe");
        sleep(1);
    }

    return 0;
}

运行结果：无内容打印

稍微改一下代码

while(true)
{
    //能触发行缓冲的刷新策略
    printf("%s\n", "hehehehe");
    sleep(1);
}

运行结果：每隔一秒，打印一次

3.3、普通缓冲区与内核级缓冲区

每一个 file 对象中都有属于自己的缓冲区及刷新策略，而在系统中，还存在一个内核级缓冲区，这个缓冲区才是 CPU 真正进行 IO 的区域

IO 流程：

• 先将普通缓冲区中的数据刷新至内核级缓冲区中，CPU 再从内核级缓冲区中取数据进行运算，然后存入内核级缓冲区中，最后再由内核级缓冲区冲刷给普通缓冲区

出自知乎 《Linux 实现原理 — I/O 处理流程与优化手段》

这里有一段比较有意思的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <unistd.h>

using namespace std;

int main()
{
    fprintf(stdout, "hello fprintf\n");
    const char* str = "hello write\n";
    write(1, str, strlen(str));

    fork(); //创建子进程
    return 0;
}

当我们直接运行程序时，结果如下：

而当我们进行重定向后，结果如下：

重定向前后出现两种截然不同的打印结果

原因分析：

• 显示器刷新策略为 行缓冲，而普通文件为 全缓冲
• 直接运行程序时：此时是向 显示器 中打印内容，因为有 \n，所以两条语句都直接进行了冲刷
• 进行重定向后：此时是向 普通文件 中打印内容，因为普通文件是写满后才能刷新，并且 fprintf 有属于自己的缓冲区，这就导致 fork() 创建子进程后，父子进程的 fprintf 缓冲区中都有内容，当程序运行结束后，统一刷新，于是就是打印了两次 hello fprintf

注：系统级接口是没有自己的缓冲区的，直接冲刷至内核级缓冲区中，比如 write，所以创建子进程对 write 的冲刷没有任何影响

C语言 中的 FILE 类型设计还是比较复杂的，需要考虑很多种情况，不过本质上都是在调用系统级接口，我们现在已经可以模拟实现一个简易版 myFILE 结构体了，具体实现步骤将在下文中揭晓

---

🌆总结

以上就是本次有关 Linux 基础IO【重定向及缓冲区理解】的全部内容了，在这篇文章中，我们深入理解了文件描述符的概念，学习了重定向的多种方法，最后还学习了缓冲区的相关知识，清楚了普通文件与特殊文件的不同刷新策略。如果你对于本文中所提到的知识点还有疑惑的话，欢迎在评论区或私信中发表你的看法，我们可以相互探讨学习

---

相关文章推荐
Linux基础IO【文件理解与操作】

Linux【模拟实现简易版bash】

Linux进程控制【进程程序替换】

Linux进程控制【创建、终止、等待】

===============

Linux进程学习【进程地址】

Linux进程学习【环境变量】

Linux进程学习【进程状态】

Linux进程学习【基本认知】