这篇文章就从基础概念出发，一步步拆解 Linux 基础 IO 的核心知识点：从 “文件是什么” 到 C 库接口、系统调用，再到文件描述符、重定向、缓冲区机制，最后结合实战代码帮你学习在Linux中，“文件”的概念被无限放大——一切皆文件，这是理解Linux IO的核心前提。无论是什么类型的文件，其本质都是“属性(元数据)+内容”的集合- 内容：文件存储的实际数据(比如文本，图片，二进制指令)
- 属性：文件的描述信息(比如权限，大小，创建时间，所有者等)
哪怕是大小为0的空文件，也会在磁盘上占据空间——因为要存储它的属性信息。对文件的所有操作(读，写，修改)，本质都是围绕"属性"或"内容"展开的- 狭义理解：磁盘上的永久存储文件（文档、图片、可执行程序等），磁盘是外设，因此文件操作本质是对外设的输入 / 输出（IO）；
- 广义理解：Linux 中，键盘、显示器、网卡、鼠标、管道、套接字等都被抽象为文件，统一通过文件操作接口访问，屏蔽了底层硬件的差异。
- 对文件的操作，本质是进程对文件的操作——文件由进程打开，读写，关闭
- 磁盘的管理者是操作系统，进程不能直接操作磁盘，必须通过系统提供的"系统调用接口"间接操作文件
简单说：进程是文件操作的主体，操作系统是文件操作的"中间人"，文件是操作的对象。C 语言提供了一套标准 IO 库函数，封装了底层的系统调用，方便开发者使用。#include<stdio.h>FILE* fopen(constchar* path,constchar* mode);
- 返回值：成功返回FILE*文件指针，失败返回NULL
//二进制写size_tfwrite(constchar* ptr,size_t size,size_t nmemb,FILE* stream);//字符串写intfputs(constchar* s,FILE* stream);//格式化写intfprintf(FILE* stream,constchar* format,.....);
#include<stdio.h>#include<string.h>intmain(){ FILE* fp = fopen("log.txt","w"); if(fp == NULL){ printf("fopen error!\n"); return 1; } const char* msg = "hello 123\n"; int cnt = 5; while(cnt--) { fwrite(msg,strlen(msg),1,fp); } fclose(fp); return 0;}
//二进制读size_tfread(void* ptr,size_t size,size_t nmemv,FILE* stream);//按行读char* fgets(char* s,int size,FILE* stream);
#include<stdio.h>#include<string.h>intmain(){ FILE* fp = fopen("log.txt","r"); if(!fp) { printf("fopen error!\n"); return 1; } char buf[1024]; const char* msg = "hello 123\n"; while(1) { //每次读1个字节，共读strlen(msg)个字节 size_t s = fread(buf,1.strlen(ms),fp); if(s>0) { buf[s] = '\0'; printf("%s",buf); } //检测文件结尾 if(feof(fp)) break; } return 0;}
特殊的文件流：stdin,stdout,stderrC语言启动时，会默认打开3个标准文件流，类型都是FILE*stdin：标准输入，对应键盘（文件描述符 0）；
stdout：标准输出，对应显示器（文件描述符 1）；
stderr：标准错误，对应显示器（文件描述符 2）
这也是为什么我们不用手动打开，就能直接使用printf（默认输出到 stdout）、scanf（默认从 stdin 读取）的原因。#include<stdio.h>#include<string.h>intmain(){ const char* msg1 = "hello1\n"; const char* msg2 = "hello2\n"; // 三种向stdout输出的方式 printf("%s", msg1); fprintf(stdout, "%s", msg2); fwrite(msg1, strlen(msg1), 1, stdout); // 向stderr输出（错误信息） fprintf(stderr, "this is error message\n"); return 0;}
//cat.c#include<stdio.h>#include<string.h>intmain(int argc, char *argv[]){ //cat log.txt if(argc != 2) { printf("%s filename\n",argv[0]); return 1; } FILE* fp = fopen(argv[1],"r"); if(!fp) { printf("fopen error!\n"); return 2; } char buf[1024]; while(1) { 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;}
编译运行：gcc cat.c -o mycat，执行./mycat myfile即可C库IO函数本质是对系统调用接口的封装，操作系统才是文件操作的最终执行者，掌握系统调用接口，才能真正理解文件操作的底层逻辑3.1 核心系统调用接口
1. 打开文件：open
#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>//打开已存在的文件intopen(constchar* path_name,int flags);//创建并打开文件(文件不存在时)intopen(constchar* path_name,int flags,mode_t mode);
- mode:文件权限(仅创建文件时有效，如0666表示所有者，组，其他用户都有读写权限)
注意：文件权限最终是mode & ~umask，默认umask是 0022，因此0666最终会变成0644（去掉组和其他用户的写权限），若想保留0666权限，需先设置umask(0)。#include<unistd.h>ssize_twrite(int fd, constvoid *buf, size_t count);
#include<unistd.h>ssize_tread(int fd, void *buf, size_t count);
- 返回值：成功返回实际读取的字节数，返回0表示到达文件结尾，失败返回-1
#include<unistd.h>intclose(int fd);
// 写文件#include<stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<unistd.h>#include<string.h>intmain(){ umask(0); int fd = open("myfile",O_WRONLY|O_CREAT|O_TRUNC,0666); if(fd < 0) { perror("open"); return 1; } const char* msg = "Linux1\n"; int cnt = 3; while(cnt--) { write(fd,msg,strlen(msg)); } close(fd); return 0;}//读文件intmain(){ int fd = open("myfile",O_RDONLY); if(fd < 0) { perror("open"); return 1; } char buf[1024]; const char* msg = "Linux1\n"; while(1) { ssize_t s = read(fd,buf,strlen(msg)); if(s >= 0) printf("%s",buf); else break; //s<0(失败)退出 } close(fd); return 0;}
3.3 库函数与系统调用的关系
C 库 IO 函数（fopen、fwrite）是对系统调用（open、write）的封装，关系如下：
- 库函数：用户态接口，提供缓冲区等优化，方便开发者使用；
- 系统调用：内核态接口，是文件操作的最终实现，需要切换 CPU 状态（用户态→内核态）。
简单说：fwrite会先将数据写入用户态缓冲区，满足条件后再调用write写入内核缓冲区，最终由操作系统写入磁盘。
- 文件描述符（fd）是一个非负整数（0、1、2、3...），是进程与打开文件之间的 “桥梁”；
- 在内存中创建一个
struct file结构体（描述文件属性、缓冲区、读写位置等）； - 在进程的文件描述符表（
files_struct）中，找到一个未使用的最小整数，作为 fd，指向这个struct file；
- 后续对文件的读写操作，都通过这个 fd 来找到对应的
struct file
struct file就代表 被打开的文件。对被打开文件的管理，转化成了对链表的增删查改
在操作系统内部，每次打开一个文件，就创建一个sturct file类的对象。
在文件当中，会提供一个文件缓冲区。文件的内容会加载到缓冲区，文件的属性，会用来初始化struct file。
要读取文件的内容，要先把文件打开，创建struct file，通过file内部的指针找到缓冲区，把内容加载到缓冲区里。读文件的本质，就从文件缓冲区里，把数据拷贝上去。
进程：打开文件 == 1：n，一个进程可以打开多个文件
那么，哪些文件和进程是强相关的呢？
在进程PCB当中，当一个进程被创建，除了地址空间，页表，还要创建一个struct files_struct，叫做文件描述符表。
这个叫指针数组，在task_struct里面，会存在一个stuct files_struct*类型的指针，指向这个结构体
结构体指针数组，数组里面放的，是该进程打开的文件。
这样就能够建立了被打开的文件和进程之间的映射关系。
文件描述符的本质是数组下标，是内核下，进程所对应的，文件描述符表的数组下标
read函数本质是拷贝函数，内核到用户空间的拷贝函数。
进程启动时，会默认打开3个文件描述符，对应3个标准文件流重定向是Linux中常用的功能(如ls > log.txt)，其本质是改变文件描述符表中fd的指向，让原本指向A文件的fd，指向B文件手动实现输出重定向
比如，让printf的输出写入文件（而非显示器），核心步骤：
printf默认写入 stdout（fd=1），此时 fd=1 指向文件，实现重定向。
#include<stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<stdlib.h>intmain(){ close(1); //关闭stdout int fd = open("log.txt",O_WRONLY | O_CREAT | O_TRUNC,0666); if(fd < 0) { perror("open fail"); return 1; } printf("fd:%d\n",fd); fflush(stdout); close(fd); return 0;}
运行后，log.txt中会出现fd: 1，说明重定向成功。文件描述符的分配规则：在 files_struct 数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。
那重定向的本质是什么呢？
文件描述符的原则：最小的，没有被使用的，作为新的fd给用户
printf是C语言提供的函数，是往stdout里面去打的，stdout->1
上面两行代码是操作系统内部做的，printf只认stdout->1，往1打。并不关心stdout->1指向谁。
换句话说。
printf 是 C 库当中的 IO 函数，一般往 stdout 中输出，但是 stdout 底层访问文件的时候，找的还是 fd:1，但此时，fd:1 下标所表示内容，已经变成了 myfile 的地址，不再是显示器文件的地址，所以，输出的任何消息都会往文件中写入，进而完成输出重定向
在底层中，更改一个文件描述符，对用户来说完全透明，这种叫做重定向
重定向：更改文件描述符表的指针指向。数组下标不变
系统调用 dup2：更优雅的重定向
dup2函数专门用于重定向，功能是 “让 newfd 指向 oldfd 指向的文件”：
#include<unistd.h>intdup2(int oldfd, int newfd);
#include<stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<unistd.h>intmain(){ int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666); if (fd < 0) { perror("open"); return 1; } // 让fd=1指向fd指向的文件（log.txt） dup2(fd, 1); printf("hello dup2\n"); // 写入log.txt fflush(stdout); close(fd); return 0;}
5.1 什么是缓冲区？
缓冲区是内存中的一块空间，用于临时存储输入 / 输出数据，核心目的是减少系统调用次数，提高效率。
- 写操作：数据先写入缓冲区，满足一定条件后，再批量写入内核 / 磁盘，避免频繁的用户态→内核态切换；
- 读操作：数据先从磁盘 / 内核读取到缓冲区，后续读取直接从缓冲区获取，提高读取速度。
5.2 为什么需要缓冲区？
系统调用的成本很高 —— 每次调用都需要切换 CPU 状态（用户态→内核态），频繁的系统调用会严重影响程序效率。
比如，向磁盘写入 1000 次 1 字节数据：
- 无缓冲区：需要 1000 次系统调用，切换 1000 次 CPU 状态；
- 有缓冲区：先将 1000 字节数据写入缓冲区，再一次系统调用写入磁盘，仅切换 1 次 CPU 状态。
5.3 三种缓冲类型
C 标准库提供了 3 种缓冲类型，不同场景对应不同的缓冲策略：
关键特性：
- 重定向会改变缓冲类型：stdout 默认是行缓冲（输出到显示器），若重定向到文件，会变成全缓冲；
- stderr 始终是无缓冲：确保错误信息能及时输出，不会因为缓冲区未刷新而丢失。
5.4 缓冲区的位置：用户态 vs 内核态
缓冲区分为两层，很多开发者会混淆：
- 用户态缓冲区：由 C 库提供（封装在
FILE结构体中），比如printf、fwrite使用的缓冲区； - 内核态缓冲区：由操作系统提供，
write系统调用会将数据写入内核缓冲区，操作系统再决定何时写入磁盘。
用户数据 → 用户态缓冲区 → 内核态缓冲区 → 磁盘5.5 实战：缓冲区的那些坑
坑 1：重定向后 printf 不输出
#include<stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<unistd.h>intmain(){ close(1); int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666); if (fd < 0) { perror("open"); return 0; } printf("hello world: %d\n", fd); // 重定向到文件，全缓冲 close(fd); // 缓冲区未满，数据未刷新，log.txt为空 return 0;}
为什么close(fd)之后，反而不往文件里写了？
printf时候，格式化输出的字符串，没有写到文件内核缓冲区里，在语言层的缓冲区里
调用close时，进程还没有结束。然后进程退出。要刷新到文件里，调用系统调用write，但此时fd已经关了，无法把数据从语言层交到操作系统内
解决方法：调用fflush(stdout)强制刷新缓冲区，或让进程正常退出（会自动刷新）我们打开文件时，会有一个FILE*
FILE是什么呢？FILE是C语言提供的一个结构体。里面封装了int fd，缓冲区
一，立即刷新 --- 无缓冲 --- 写透模式WT
二，缓冲区写满了 --- 全缓冲->写满缓冲区，效率最高！向普通文件，一般采用这种方式
三， 行刷新 --- 行缓冲->一般是显示器在用
#include<stdio.h>#include<string.h>#include<unistd.h>intmain(){ const char *msg0 = "hello printf\n"; const char *msg1 = "hello fwrite\n"; const char *msg2 = "hello write\n"; printf("%s", msg0); fwrite(msg1, strlen(msg1), 1, stdout); write(1, msg2, strlen(msg2)); fork(); // 创建子进程 return 0;}
- 直接运行（输出到显示器，行缓冲）：输出 3 行（msg0、msg1、msg2 各 1 次）；
- 重定向到文件（全缓冲）：输出 5 行（msg0、msg1 各 2 次，msg2 1 次）。
原因：fork的时候，对应缓冲区里，2条消息，在fork执行的时候，还在缓冲区里。fork结束时，父子各自都要刷新一次(后面的刷新也是共享的)。
write是系统调用，它会直接把数据写入内核缓冲区，不经过用户态缓冲区
重定向，还更改了文件的刷新方式！如果直接向显示器文件写，刷新方式是行刷新！如果向文件里写，则是全缓冲.进程退出时，父子进程都要刷新缓冲区导致 msg0、msg1 各输出 2 次；
访问设备，都是通过函数指针来访问的。函数指针类型命名，参数，都一样！屏蔽了底层的硬件的差异。
把struct file这一层，叫做VFS(虚拟文件系统)
在系统当中，访问任何设备，最终只要提供文件描述符，就不用关心底层用户的差异。直接去使用struct file内部的函数指针，来做对硬件的访问
首先，在 windows 中是文件的东西，它们在 linux 中也是文件；其次一些在 windows 中不是文件的东西，比如进程、磁盘、显示器、键盘这样硬件设备也被抽象成了文件，你可以使用访问文件的方法访问它们获得信息；甚至管道，也是文件；
这样做最明显的好处是，开发者仅需要使用一套 API 和开发工具，即可调取 Linux 系统中绝大部分的资源。举个简单的例子，Linux 中几乎所有读（读文件，读系统状态，读 PIPE）的操作都可以用read函数来进行；几乎所有更改（更改文件，更改系统参数，写 PIPE）的操作都可以用write函数来进行
上图中的外设，每个设备都可以有自己的 read, write，但一定是对应着不同的操作方法！！但通过struct file下file_operation中的各种函数回调，让我们开发者只用 file 便可调取 Linux 系统中绝大部分的资源！！这便是 “linux 下一切皆文件” 的核心理解。
