Linux：认识基础IO

1.理解"⽂件"

1.1狭义理解

• ⽂件在磁盘⾥
• 磁盘是永久性存储介质，因此⽂件在磁盘上的存储是永久性的
• 磁盘是外设（即是输出设备也是输⼊设备）
• 磁盘上的⽂件 本质是对⽂件的所有操作，都是对外设的输⼊和输出 简称 IO

1.2广义理解

Linux 下⼀切皆⽂件（键盘、显⽰器、⽹卡、磁盘…… 这些都是抽象化的过程） 

1.3⽂件操作的归类认知 

• 对于 0KB 的空⽂件是占⽤磁盘空间的
• ⽂件是⽂件属性（元数据）和⽂件内容的集合（⽂件 = 属性（元数据）+ 内容）
• 所有的⽂件操作本质是⽂件内容操作和⽂件属性操作

1.4系统角度

• 对⽂件的操作本质是进程对⽂件的操作
• 磁盘的管理者是操作系统

2.C文件接口 

fopen()：打开文件

#include <stdio.h>//FILE *fopen(const char *path, const char *mode);
int main()
{FILE* fp = fopen("myfile", "w");if (!fp) {printf("fopen error!\n");}while (1);fclose(fp);return 0;
}

• path：文件路径。
• mode：打开模式（见下表）。
• 成功：返回 FILE* 流指针。
• 失败：返回 NULL，并设置 errno。

文件打开模式​​

fwrite()：写入文件​

#include <stdio.h>
#include <string.h>//size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
int main()
{FILE* fp = fopen("myfile", "w");if (!fp) {printf("fopen error!\n");}const char* msg = "hello bit!\n";int count = 5;while (count--) {fwrite(msg, strlen(msg), 1, fp);//fwrite(msg, 1, strlen(msg), fp);}fclose(fp);return 0;
}

• ptr：要写入的数据指针。
• size：每个数据项的字节数（如 sizeof(int)）。
• nmemb：要写入的数据项数量。
• stream：FILE* 流。
• 成功：返回实际写入的数据项数量（可能小于 nmemb）。
• 失败：返回 0 或 EOF（需检查 ferror(fp)）

差异 

 区别

 fread()：读取文件​

#include <stdio.h>
#include <string.h>//size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
int main()
{FILE* fp = fopen("myfile", "r");if (!fp) {printf("fopen error!\n");return 1;}char buf[1024];const char* msg = "hello bit!\n";while (1) {//注意返回值和参数ssize_t s = fread(buf, 1, strlen(msg), fp);if (s > 0) {buf[s] = 0;printf("%s", buf);}if (feof(fp)) {break;}}fclose(fp);return 0;
}

• ptr：存储读取数据的缓冲区。
• size：每个数据项的字节数。
• nmemb：要读取的数据项数量。
• stream：FILE* 流。
• 成功：返回实际读取的数据项数量（可能小于 nmemb）。
• ​​EOF​​：返回 0（需用 feof(fp) 检查是否到达文件末尾）。
• 失败：返回 0 或 EOF（检查 ferror(fp)）。

stdin & stdout & stderr

• C默认会打开三个输⼊输出流，分别是stdin, stdout, stderr
• 仔细观察发现，这三个流的类型都是FILE*, fopen返回值类型，⽂件指针

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

3.系统⽂件I/O

3.1⼀种传递标志位的⽅法 

#include <stdio.h>
#define ONE 0001 //0000 0001
#define TWO 0002 //0000 0010
#define THREE 0004 //0000 0100
void func(int flags) {if (flags & ONE) printf("flags has ONE! ");if (flags & TWO) printf("flags has TWO! ");if (flags & THREE) printf("flags has THREE! ");printf("\n");
}
int main() {func(ONE);func(THREE);func(ONE | TWO);func(ONE | THREE | TWO);return 0;
}

3.2系统接口

open()：打开文件​

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>//int open(const char *pathname, int flags, mode_t mode);int fd = open("data.txt", O_RDWR | O_CREAT, 0644); // 读写模式，不存在则创建
if (fd == -1) {perror("open failed");exit(1);
}

• pathname：文件路径（如 "./test.txt"）。
• flags：打开方式（见下表）。
• mode（可选）：文件权限（仅在 O_CREAT 时有效，如 0644）。
• 成功：返回文件描述符。
• 失败：返回 -1，并设置 errno。

read()：读取文件​

#include <unistd.h>
//ssize_t read(int fd, void *buf, size_t count);char buf[1024];
ssize_t bytes_read = read(fd, buf, sizeof(buf));
if (bytes_read == -1) {perror("read failed");
} else if (bytes_read == 0) {printf("EOF reached\n");
} else {printf("Read %zd bytes: %.*s\n", bytes_read, (int)bytes_read, buf);
}

• fd：文件描述符（由 open() 返回）。
• buf：存储读取数据的缓冲区。
• count：要读取的最大字节数。
• 成功：返回实际读取的字节数（可能小于 count）。
• 文件结束（EOF）：返回 0。
• 失败：返回 -1，并设置 errno。

write()：写入文件​ 

#include <unistd.h>//ssize_t write(int fd, const void *buf, size_t count);const char *msg = "Hello, world!\n";
ssize_t bytes_written = write(fd, msg, strlen(msg));
if (bytes_written == -1) {perror("write failed");
} else if (bytes_written < strlen(msg)) {printf("Partial write: %zd/%zu bytes\n", bytes_written, strlen(msg));
}

• fd：文件描述符。
• buf：要写入的数据指针。
• count：要写入的字节数。
• 成功：返回实际写入的字节数（可能小于 count）。
• 失败：返回 -1，并设置 errno。

关键注意事项​​

​​(1) 文件描述符 vs FILE*​​

• open() 返回 int 文件描述符，需用 read()/write() 操作。
• fopen() 返回 FILE*，需用 fread()/fwrite() 操作。
• ​​不要混用​​：例如用 write() 写入 fopen() 打开的文件。 

(2) 缓冲区别​​

• write()：无缓冲，数据直接进入内核缓冲区（但不一定立即落盘）。
• fwrite()：带缓冲，数据先存到 stdio 缓冲区，满后才调用 write()。

3.3先来认识⼀下两个概念: 系统调⽤ 和 库函数 

• 上⾯的 fopen fclose fread fwrite 都是C标准库当中的函数，我们称之为库函数（libc）。
• ⽽ open close read write lseek 都属于系统提供的接⼝，称之为系统调⽤接⼝。

3.4⽂件描述符fd 

通过对open函数的学习，我们知道了⽂件描述符就是⼀个⼩整数 

3.4.1  0 & 1 & 2

• Linux进程默认情况下会有3个缺省打开的⽂件描述符，分别是标准输⼊0， 标准输出1， 标准错误2.
• 0,1,2对应的物理设备⼀般是：键盘，显⽰器，显⽰器

所以输⼊输出还可以采⽤如下⽅式：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main()
{char buf[1024];ssize_t s = read(0, buf, sizeof(buf));if (s > 0) {buf[s] = 0;write(1, buf, strlen(buf));write(2, buf, strlen(buf));}return 0;
}

现在知道，⽂件描述符就是从0开始的⼩整数。当我们打开⽂件时，操作系统在内存中要创建相应的数据结构来描述⽬标⽂件。于是就有了file结构体。表⽰⼀个已经打开的⽂件对象。⽽进程执⾏open系统调⽤，所以必须让进程和⽂件关联起来。每个进程都有⼀个指针*files, 指向⼀张表files_struct,该表最重要的部分就是包含⼀个指针数组，每个元素都是⼀个指向打开⽂件的指针！所以，本质上，⽂件描述符就是该数组的下标。所以，只要拿着⽂件描述符，就可以找到对应的⽂件。

 3.4.2文件描述符的分配规则

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{int fd = open("myfile", O_RDONLY);if (fd < 0) {perror("open");return 1;}printf("fd: %d\n", fd);close(fd);return 0;
}

 输出发现是 fd: 3

关闭0或者2，在看

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{close(0);//close(2);int fd = open("myfile", O_RDONLY);if (fd < 0) {perror("open");return 1;}printf("fd: %d\n", fd);close(fd);return 0;
}

发现是结果是： fd: 0 或者 fd 2 ，可⻅，⽂件描述符的分配规则：在files_struct数组当中，找到当前没有被使⽤的最⼩的⼀个下标，作为新的⽂件描述符。

3.4.3重定向 

那如果关闭1呢？看代码： 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main()
{close(1);int fd = open("myfile", O_WRONLY | O_CREAT, 00644);if (fd < 0) {perror("open");return 1;}printf("fd: %d\n", fd);fflush(stdout);close(fd);exit(0);
}

3.4.4使⽤ dup2 系统调⽤ 

 函数原型

#include <unistd.h>
int dup2(int oldfd, int newfd);

示例 

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main() {int fd = open("./log", O_CREAT | O_RDWR);if (fd < 0) {perror("open");return 1;}close(1);dup2(fd, 1);for (;;) {char buf[1024] = { 0 };ssize_t read_size = read(0, buf, sizeof(buf) - 1);if (read_size < 0) {perror("read");break;}printf("%s", buf);fflush(stdout);}return 0;
}

printf是C库当中的IO函数，⼀般往 stdout 中输出，但是stdout底层访问⽂件的时候，找的还是fd:1, 但此时，fd:1下标所表⽰内容，已经变成了myfifile的地址，不再是显⽰器⽂件的地址，所以，输出的任何消息都会往⽂件中写⼊，进⽽完成输出重定向。

4.缓冲区 

4.1什么是缓冲区 

 4.2为什么要引⼊缓冲区机制

读写⽂件时，如果不会开辟对⽂件操作的缓冲区，直接通过系统调⽤对磁盘进⾏操作(读、写等)，那么每次对⽂件进⾏⼀次读写操作时，都需要使⽤读写系统调⽤来处理此操作，即需要执⾏⼀次系统调⽤，执⾏⼀次系统调⽤将涉及到CPU状态的切换，即从⽤⼾空间切换到内核空间，实现进程上下⽂的切换，这将损耗⼀定的CPU时间，频繁的磁盘访问对程序的执⾏效率造成很⼤的影响。

 

为了减少使⽤系统调⽤的次数，提⾼效率，我们就可以采⽤缓冲机制。⽐如我们从磁盘⾥取信息，可以在磁盘⽂件进⾏操作时，可以⼀次从⽂件中读出⼤量的数据到缓冲区中，以后对这部分的访问就不需要再使⽤系统调⽤了，等缓冲区的数据取完后再去磁盘中读取，这样就可以减少磁盘的读写次数，再加上计算机对缓冲区的操作⼤ 快于对磁盘的操作，故应⽤缓冲区可⼤ 提⾼计算机的运⾏速度。

4.3缓冲类型 

标准I/O提供了3种类型的缓冲区

• 全缓冲区：这种缓冲⽅式要求填满整个缓冲区后才进⾏I/O系统调⽤操作。对于磁盘⽂件的操作通常使⽤全缓冲的⽅式访问。
• ⾏缓冲区：在⾏缓冲情况下，当在输⼊和输出中遇到换⾏符时，标准I/O库函数将会执⾏系统调⽤操作。当所操作的流涉及⼀个终端时（例如标准输⼊和标准输出），使⽤⾏缓冲⽅式。因为标准I/O库每⾏的缓冲区⻓度是固定的，所以只要填满了缓冲区，即使还没有遇到换⾏符，也会执⾏I/O系统调⽤操作，默认⾏缓冲区的⼤⼩为1024。
• ⽆缓冲区：⽆缓冲区是指标准I/O库不对字符进⾏缓存，直接调⽤系统调⽤。

•  缓冲区满时；
• 执⾏flush语句；

 4.4FILE

#include <stdio.h>
#include <string.h>
int main()
{const char* msg0 = "hello printf\n";const char* msg1 = "hello fwrite\n";const char* msg2 = "hello write\n";printf("%s", msg0);fwrite(msg1, strlen(msg0), 1, stdout);write(1, msg2, strlen(msg2));fork();return 0;
}

hello printf
hello fwrite
hello write

hello write
hello printf
hello fwrite
hello printf
hello fwrite