Linux（11)——基础IO（上）

一、理解文件

二、回顾C文件的接口

📄 C语言文件操作函数表

编辑📄 三个文件流

三、系统文件I/O

1️⃣open

2️⃣close

3️⃣write

4️⃣read

四、文件描述符

💡用户操作文件的底层逻辑是什么？

💡什么是进程创建的时候会默认打开0、1、2？

五、文件描述符的分配规则

一、理解文件

我们来以三个问题来切入

💡文件大小为0时，要不要占用空间呢？

答案毋庸置疑是要的，因为除了内容之外，还有文件的相关属性，这里我们要明确一点就是文件=内容+属性（也叫元数据）。

💡访问文件需要打开文件，谁来打开呢？

实际上是进程来打开文件，对文件的操作本质上还是进程对文件的操作，而根本上还是系统对于文件的一系列的调用。

💡操作系统要不要管理被打开的文件，怎么管理？

答案是要管理，还是我们之前说的先描述，再组织。

二、回顾C文件的接口

📄 C语言文件操作函数表

函数名	功能说明	返回值说明
`fopen()`	打开一个文件	成功返回 `FILE*`，失败 `NULL`
`fclose()`	关闭一个已打开的文件	成功返回 `0`，失败 `EOF`
`fread()`	从文件中读取数据	返回实际读取的元素数量
`fwrite()`	向文件写入数据	返回实际写入的元素数量
`fgetc()`	从文件读取一个字符	成功返回字符，失败 `EOF`
`fputc()`	向文件写入一个字符	成功返回字符，失败 `EOF`
`fgets()`	从文件读取一行字符串	成功返回字符串，失败 `NULL`
`fputs()`	向文件写入一个字符串	成功返回非负值，失败 `EOF`
`fprintf()`	向文件格式化输出	返回写入的字符数
`fscanf()`	从文件格式化输入	成功读取项数
`ftell()`	获取文件当前位置（偏移量）	成功返回位置，失败 `-1L`
`fseek()`	设置文件位置指针	成功返回 `0`，失败非零
`rewind()`	将文件位置指针重置到文件开头	无返回值
`feof()`	检查文件是否到达 EOF	是返回非零，否返回 `0`
`ferror()`	检查文件操作是否发生错误	有错返回非零，无错返回 `0`
`clearerr()`	清除文件错误和 EOF 标志	无返回值
`remove()`	删除一个文件	成功返回 `0`，失败非零
`rename()`	重命名一个文件	成功返回 `0`，失败非零
`tmpfile()`	创建一个临时二进制文件	成功返回 `FILE*`，失败 `NULL`
`setbuf()`	设置文件缓冲区	无返回值
`setvbuf()`	设置缓冲方式和缓冲区大小	成功返回 `0`，失败非零

这里不过多介绍了，感兴趣的友友可以移步至：文件读写https://blog.csdn.net/2301_80065652/article/details/141182826

下面我们来写几个读写方面的例子：

写操作：

读操作：

下面这个函数一定要注意了，函数原型是：

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

参数说明：

参数名	含义
`ptr`	指向存储读取数据的内存地址（缓冲区）
`size`	单个数据项的字节数
`nmemb`	要读取的数据项个数
`stream`	文件指针

返回值说明：返回成功读取的数据项数量（即不是字节数，是数据项个数），如果出错或到达文件末尾，返回值可能小于nmemb。

所以下面这个代码是在每次读stelen（msg）（包含了回车）个字节，并在末尾置0以输出字符串。

输出到屏幕的操作：

其实这里的代码和上面的写操作是很一样的，这是因为输出到文件就是对屏幕文件进行写操作。

📄 三个文件流

我们现在要明确一个概念那就是“一切皆文件”，也就是说在Linux下一切都是可以用文件来表示的，包括但不限于键盘文件和屏幕文件，电脑通过从键盘文件中获取数据然后再向屏幕文件中写数据来显示我们输入的内容。

但是我们在实际操作的时候并没有说是去打开某个键盘文件或是屏幕文件，实际上是操作系统默认帮我们打开了三个文件流，他们分别是标准输入流（stdin），标准输出流（stdout）和标准错误流（stderr），同时呢他们又分别是键盘文件，显示器文件和显示器文件。

#include <stdio.h>

extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;

我们发现这里的返回值类型和我们fwrite函数和fprintf函数中的参数类型是一样的，都是FILE*类型。

敲黑板：

其实我们见过的绝大多数语言是有这三个文件流的，比如Java和Python。

三、系统文件I/O

其实我们在C语言和C++中用用到的fopen（C语言）和ifstream（C++）都是语言层上面的调用，实际上呢在系统层面都是有自己行对应的接口的，而语言层只是对系统层的一个封装罢了，这样的封装更加易用且有自己的缓冲机制。接下来我们谈谈四大底层文件的接口：

1️⃣open

函数原型：

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

参数说明：

第一个参数pathname是要打开的文件名或是要创建的目标文件。

第二个参数是flags表示的是打开文件的方式，如图：

参数	含义
`O_RDONLY`	只读打开
`O_WRONLY`	只写打开
`O_RDWR`	读写打开
`O_CREAT`	文件不存在则创建（需配合 `mode` 参数）
`O_APPEND`	写入时追加到文件尾
`O_TRUNC`	如果文件存在则清空
`O_EXCL`	与 `O_CREAT` 一起使用时，文件存在就报错
`O_NONBLOCK`	非阻塞打开

这里就不得不提一下传递多个像这要的标志位的方法了：

给出一个例子来说明

#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;
}

就是说实际上这里的flags的传递也是这样的方式，我们可以在bits/fcntl-linux.h文件中见一见：

可以见到：

/* From /usr/include/asm-generic/fcntl.h */
#define O_RDONLY        00
#define O_WRONLY        01
#define O_RDWR          02
#define O_CREAT       0100 /* not fcntl */
#define O_EXCL        0200 /* not fcntl */
#define O_TRUNC      01000 /* not fcntl */
#define O_APPEND     02000
#define O_NONBLOCK   04000

第三个参数是mode，表示文件创建出来的权限，这是一个可选项（因为也可以只是打开文件）：

我们在之前谈文件权限时提到了权限源码的概念，也就是说这里设置的权限需要进行计算（mode&(~umask)）才是最终的权限，如果我们想让这个权限就是最终的权限可以将unmask设置为0。

返回值：

这个函数的返回值就是一个文件描述符（file descriptor），类型为int。

我么可以写个代码来看看：

#include <stdio.h>    
#include <sys/stat.h>    
#include <sys/types.h>    
#include <fcntl.h>    
    
int main()    
{    
    umask(0);    
    int fd1 = open("test1.txt", O_RDONLY | O_CREAT, 0666);    
    int fd2 = open("test2.txt", O_RDONLY | O_CREAT, 0666);    
    int fd3 = open("test3.txt", O_RDONLY | O_CREAT, 0666);    
    int fd4 = open("test4.txt", O_RDONLY | O_CREAT, 0666);    
    int fd5 = open("test5.txt", O_RDONLY | O_CREAT, 0666);    
    
    printf("fd1:%d\n", fd1);    
    printf("fd2:%d\n", fd2);    
    printf("fd3:%d\n", fd3);    
    printf("fd4:%d\n", fd4);    
    printf("fd5:%d\n", fd5);    
    return 0;                                                                                                                                                                       
}

我们也可以尝试打开不存在的文件试试：

我们发现他的文件描述符是-1。

这里的文件描述符实际上就是一个指针数组的下标，而指针数组中的指针就指向了被打开了的文件的文件的信息。这也就说明了我们打开文件其实就是依次增加被打开文件的个数相应的就增加了数组指针的下标了，而如果没有访问到这个文件那么就返回-1。但是我们会发现我们在上面的打印信息中的下标并不是从1开始的，这是因为我们之前讲的进程会默认打开三个文件，也就是标准输入0，标准输出1，标准错误2。

2️⃣close

这个接口没啥好说的了，就是关闭打开的文件：

#include <unistd.h>

int close(int fd);

传入要关闭的文件描述符，如果关闭成功就返回0，否则返回-1。

示例：

3️⃣write

用于将数据从内存写入一个文件描述符所代表的目标：

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

参数说明：

fd：文件描述符

buf：指向要写入的数据的内存地址

count：要写入的字节数

返回值：

成功：返回写入的字节数(可能小于count)
失败：返回 -1

我们来写个代码来验证：

#include <stdio.h>      
#include <string.h>      
#include <unistd.h>      
#include <sys/types.h>      
#include <sys/stat.h>      
#include <fcntl.h>      
      
int main()      
{      
    int fd = open("test2.txt", O_WRONLY | O_CREAT, 0666);      
    if(fd < 0){      
        perror("open errror");      
        return 1;      
    }      
    const char* msg = "hello xywl\n";                                                                                                                                               
    for(int i = 0; i < 5; i++){      
        write(fd, msg, strlen(msg));      
    }                          
    close(fd);                 
    return 0;                  
}

输出结果：

4️⃣read

用于从文件描述符中读取数据到内存：

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

参数说明：

fd：文件描述符
buf：接收数据的内存缓冲区(通常是一个数组)
count：希望读取的最大字节数

返回值：

情况	返回值
读取成功	实际读取的字节数（可能 < count）
读到文件结尾	`0`（EOF）
出错	`-1`，并设置 `errno`（如 `EBADF`、`EINTR` 等）

写个代码验证一下：

#include <fcntl.h>    
#include <unistd.h>    
#include <stdio.h>    
    
int main() {    
    int fd = open("example.txt", O_RDONLY);    
    if (fd == -1) {    
        perror("open");    
        return 1;    
    }    
    
    char buffer[128];    
    ssize_t bytes_read;    
    
    while ((bytes_read = read(fd, buffer, sizeof(buffer))) > 0) {    
       write(1, buffer, bytes_read);                                                                                                                                                
    }    
    
    if (bytes_read == -1) {    
        perror("read");    
    }    
    
    close(fd);    
    return 0;    
}

输出结果：

四、文件描述符

其实文件描述符就是操作系统内核用于表示打开的文件的一个非整数，这个我们在之前的内容中已经说明了，那么接下来我们来回答几个问题：

💡用户操作文件的底层逻辑是什么？

我们都知道程序在运行起来的时候，操作系统会将代码和数据加载到内存之中，然后会创建对应的task_struct、mm_struct、页表等相关数据结构。我们管理文件就需要一个files_struct的结构体，我们创建的task_struct中有一个指针指向这个结构体，而这个结构体中就会有一个fd_arrray数组，这个数组中存的就是我们之前说的文件描述符了。

举个例子，我们的进程要打开一个log.txt的文件，我们首先要把文件加载到内存之中，然后形成struct file结构体并把它添加到双链表中，同时将该结构体的首地址填写到对应3下标的指针数组中，然后用户就可以获取了。

💡什么是进程创建的时候会默认打开0、1、2？

进程创建的时候后默认生成这三个的struct file并连接到了双链表中，因为他们是最先创建的，所以我们也不难知道他们分别对应了文件描述符的0,1,2的下标了，这样就默认打开了标准输入流，标准输出流和标准错误流。

五、文件描述符的分配规则

我们可以以一个之前写的代码来引入：

#include <stdio.h>      
#include <sys/stat.h>      
#include <sys/types.h>      
#include <fcntl.h>      
      
int main()      
{      
    umask(0);      
    int fd1 = open("test1.txt", O_RDONLY | O_CREAT, 0666);      
    int fd2 = open("test2.txt", O_RDONLY | O_CREAT, 0666);      
    int fd3 = open("test3.txt", O_RDONLY | O_CREAT, 0666);      
    int fd4 = open("test4.txt", O_RDONLY | O_CREAT, 0666);      
    int fd5 = open("test5.txt", O_RDONLY | O_CREAT, 0666);      
      
    printf("fd1:%d\n", fd1);      
    printf("fd2:%d\n", fd2);      
    printf("fd3:%d\n", fd3);      
    printf("fd4:%d\n", fd4);      
    printf("fd5:%d\n", fd5);      
    return 0;                                                                                                                                                                                    
}

我们运行上面的发现实际上的fd是从3开始的，其实这个也不难理解，因为0，1，2是默认打开的，就相当于是已经被占用了。