【Linux】基础IO —— 上

小鱼儿 2024-04-20 06:21 56阅读 0赞

> **?Linux：基础IO详解**
> 
> --------------------
> 
>  *  **博客主页：**[一起去看日落吗][Link 1]
>  *  **分享博主的在Linux中学习到的知识和遇到的问题**
>  *  **`博主的能力有限，出现错误希望大家不吝赐教`**
>  *  **分享给大家一句我很喜欢的话：** 看似不起波澜的日复一日，一定会在某一天让你看见坚持的意义，祝我们都能在鸡零狗碎里找到闪闪的快乐???。
> 
> --------------------
> 
> ![在这里插入图片描述][0c3f31bc6bb5460689d5e339f5299830.jpeg_pic_center]

✨ ⭐️ ? ?

#### 目录 ####

*  ? 1. 简单复习文件操作
 *   *  ? 1.1 写文件
     *  ? 1.2 读文件
     *  ? 1.3 追加文件
     *  ? 1.4 一切皆文件
 *  ? 2. 系统文件I/O
 *   *  ?2.1 open
     *  ?2.2 close
     *  ?2.3 read
     *  ?2.4 write
     *  ?2.5 测试用例
 *  ? 3. 文件描述符fd
 *   *  ? 3.1 文件描述符的分配规则
 *  ? 4. 重定向原理
 *  基础IO上总结

## ? 1. 简单复习文件操作 ##

### ? 1.1 写文件 ###

如果以"w"模式打开文件，默认是文本读写，且会把原始内容清掉再写。

#include<stdio.h>
    
    int main()
    {
        
    	FILE* fp = fopen("./log.txt", "w");//以写的方式打开当前目录下的log.txt文件,没有就新建文件,如果目标文件存在,w写时会清空目标文件	
    	//FILE* fp = fopen("log.txt", "w");//没有./,它默认是在当前路径下新建文件
        if(fp == NULL)
        {
        
            perror("fopen");
            return 1;
        }
    
        int count = 0;
        while(count < 10)
        {
        
            fputs("hello byih\n", fp);//往log.txt文件中写数据
            count++;                      
        }
    
        fclose(fp);//关闭文件
    
        return 0;
    }

FILE* fp = fopen(“log.txt”, “w”);

虽然没有 ./ 指定路径，但是它还是在当前路径下新建文件了，因为每个进程都有一个内置的属性 cwd(可以在 /proc 目录下查找对应进程的属性信息)，cwd 可以让进程知道自己当前所处的路径，这也解释了在 VS 中不指明路径，它也能新建对应的文件在对应的路径，换言之，进程在哪个路径运行，文件的新建就哪个路径。

![在这里插入图片描述][773c16ffc82c493280ffcdcaceadff4a.png_pic_center]

--------------------

### ? 1.2 读文件 ###

fgets从特定文件流中按行读取，内容放在缓冲区。读取成功返回字符串起始地址，读失败返回NULL.

#include<stdio.h>
    
    int main()
    {
        
        FILE* fp = fopen("./log.txt", "r");//以读的方式打开当前目录下的log.txt文件,没有就报错
        if(fp == NULL)
        {
        
            perror("fopen");
            return 1;
        }
    
        int count = 0;
        char buffer[128];
        while(count < 10)
        {
        
            fgets(buffer, 128, fp);//从log.txt文件中读128个字符到buffer,\n会使fgets停止读取
            printf("%s\n", buffer);
            count++;
        }
    
        fclose(fp);//关闭文件
    
        return 0;
    }

--------------------

### ? 1.3 追加文件 ###

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
        
        FILE* fp = fopen("./log.txt", "a");//以追加的打开当前目录下的log.txt文件,没有就新建,如果目标文件存在,a写时不会清空目标文件,在文件内容最后写入
        if(fp == NULL)
        {
        
            perror("fopen");
            return 1;
        }
    
        const char* msg = "Hello DanceBit\n";
        //fwrite(msg, strlen(msg) + 1, 1, fp);//乱码
        fwrite(msg, strlen(msg), 1, fp);                                                                               
    
        fclose(fp);
    
        return 0;
    }

size_t fwrite ( const void* ptr, size_t size, size_t count, FILE* stream );

size 表示你要写入的基本单元是多大(以字节为单位)，count 表示你要写入几个这样的基本单元。

fwrite(msg, strlen(msg) + 1, 1, fp);

strlen(msg) + 1 -> 乱码，也就是把 \\0 也追加会造成，因为 \\0 是 C 的规定，和文件无关。这里 cat log.txt 并没有看到乱码的原因是 \\0 是不可见的，所以这里 vim log.txt 才可以看到乱码。

--------------------

### ? 1.4 一切皆文件 ###

C语言默认会打开三个输入输出流：stdin、stdout、stderr，它们的类型都是FILE\*，C语言把它们当做文件看待；站在系统角度，stdin对应的硬件设备是键盘、stdout对应显示器、stderr对应显示器，本质上我们最终都是访问硬件。C++中也有cin、cout、cerr，几乎所有语言都提供标准输入、标准输出、标准错误。

![请添加图片描述][a5748c37a0bb4aef947710c9008c7b1c.png]  
默认情况下，标准输入是键盘文件，标准输出是显示器文件，标准错误是显示器文件。**而这三个本身是硬件，如何理解 Linux 中，一切皆文件？**

所有的外设硬件，本质对应的核心操作无外乎是 read 或 write。对于键盘文件，它的读方法就是从键盘读取数据到内存，对于显示器文件，如调用 printf 函数时，操作系统是要往显示器上写入的，其实你输入的命令是你通过键盘输入的，所以系统应该是往键盘读数据。至于用户能看到输入的命令，仅仅是为了方便用户，操作系统把从键盘输入的数据，一方面给了系统读取，一方面给显示器方便用户。所以不同的硬件，对应的读写方式肯定是不一样的，但是它们都有 read 和 write 方法，换言之，这里的硬件可以统一看作一种特殊的文件。比如这里设计一种结构叫做 struct file，它包括文件的属性、文件的操作或方法等。

**Linux下的六字真言：先描述，在组织**

组织就是要把每一个硬件对应的结构体关联起来，并用 file header 指向。所以在操作系统的角度，它看到的就是一切皆文件，也就是说所有硬件的差异，经过描述，就变成了同一种东西，只不过当具体访问某种设备时，使用函数指针执行不同的方法，就达到了不同的行为。

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
        
    	const char* msg = "Hello DanceBit\n";
    	fwrite(msg, strlen(msg), 1, stdout);
    
      	char buffer[64];
      	fread(buffer, 1, 10, stdin);//你输入时没有写\0,fread时也不会加,所以一旦超过10,就会出现乱码
      	buffer[10] = '\0';
      	printf("%s\n", buffer);
    
        return 0;
    }

这里可以直接使用 fwrite 这样的接口，向显示器写数据的原因是因为 C 程序一运行，stdout 就默认打开了。同理 fread 能从键盘读数据的原因是 C 程序一运行，stdin 就默认打开了。

也就是说 C 接口除了对普通文件进行读写之外(需要打开)，还可以对 stdin、stdout、stderr 进行读写(不需要打开)。

scanf -> 键盘、printf -> 显示器、perror -> 显示器

--------------------

## ? 2. 系统文件I/O ##

如上我们知道，这些文件操作最终都是访问硬件(显示器、键盘、文件(磁盘))。众所周知，OS是硬件的管理者。所有语言上对“文件”的操作，都必须贯穿操作系统。然而OS不相信任何人，访问操作系统，就必须要通过系统接口！！

其实我们学过的几乎所有的语言中，fopen/fclose，fread/fwrite，fputs/fgets，fgets/fputs 等底层一定需要使用OS提供的系统调用接口，下面咱们就来学习文件的系统调用接口

![在这里插入图片描述][162e58b73bc54191987083765d7b975c.png]

### ?2.1 open ###

#include<stdio.h>
    #include<string.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    
    int main()
    {
        
        int fd = open("log.txt", O_WRONLY|O_CREAT, 0644);//打开
        if(fd < 0)
        {
        
            perror("open");
            return 1;
        }
    
        //操作
        const char* byh = "Hello System Call!\n";
        write(fd, byh, strlen(byh));
        write(fd, byh, strlen(byh));
        write(fd, byh, strlen(byh));
        write(fd, byh, strlen(byh));
                                                               
        close(fd);//关闭 
    
        return 0;
    }

使用 open 需要包含三个头文件，它有两个版本。版本一：以 flags 方式打开 pathname；版本二：以 flags 方式打开 pathname，并设置 mode 权限。  
![请添加图片描述][0eeea045dbee45239cf8b39bca4428d7.png]

pathname: 要打开或创建的目标文件文件名
    flags:    打开方式。传递多个标志位，下面的一个或者多个常量进行“或”运算，构成flags.
                 O_RDONLY: 只读打开
                 O_WRONLY: 只写打开
                 O_RDWR  : 读写打开
              以上这三个常量，必须指定一个且只能指定一个
                 O_CREAT : 若文件不存在，则创建它。同时需要使用mode选项，来指明新文件的访问权限
                 O_APPEND: 追加写
    mode: 	  设置默认权限信息

flags 可以是 O\_RDONLY(read-only)、O\_WRONLY(write-only)、O\_RDWR(read/write)，且必须包含以上访问模式之一。此外访问模式还可以带上 |标志位，下面会介绍一两个标志位，实际还要看场景使用。

以写的方式打开一个存在的文件，它同 fopen 一样，如果没有写操作，原文件的内容不会被覆盖；如果写操作，原文件的内容会被覆盖成写的内容。

以写的方式打开不存在的文件，权限是 644，运行程序发现没有新建文件 。

O\_CREATE 发现文件不存在，将会新建文件，且必须指定 mode 权限(如果没有指定，那么新建的文件会变成可执行程序)，如果没有 O\_CREATE，说明文件是存在的，则可忽略 mode 权限(就算写了权限也不会对原来的文件更改权限)。

--------------------

### ?2.2 close ###

![请添加图片描述][905467b55132448399c09a061ff6cf0d.png]  
使用 close 关闭文件，需要包含 unistd 头文件。fd 是 open 的返回值。

--------------------

### ?2.3 read ###

要使用 read 读文件，需要包含 unistd 头文件。read 从 fd 文件描述符中读数据到 buf，读 count 个字节，返回值是实际读到的数据。

![请添加图片描述][5fea9fef5a224b6fac5be155827c06ac.png]

#include<stdio.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    
    int main()
    {
        
        int fd = open("log.txt", O_RDONLY);//打开
        if(fd < 0)
        {
        
            perror("open");
            return 1;
        }
    
        //操作
        char buffer[1024];
        ssize_t sz = read(fd, buffer, sizeof(buffer) - 1);//期望读1023个,但实际可能只有100个,是从文件读,文件并不遵守字符串\0的规则,所以要主动\0
        if(sz > 0)
        {
        
        	buffer[sz] = '\0';//利用read的返回值,实际读到的个数就是该被\0的位置
        	printf("%s\n", buffer);
        }                                                       
    
        close(fd);//关闭 
    
        return 0;
    }

--------------------

### ?2.4 write ###

使用 write 写入文件，需要包含 unistd 头文件。write 向 fd 文件描述符中写入 buf，写 count 个字节，返回值是写了多少个

![请添加图片描述][a908cb46b75c4577a6abbfbd0c3c110c.png]

--------------------

### ?2.5 测试用例 ###

#include<string.h>  
    #include<stdio.h>  
    #include<sys/types.h>  
    #include<sys/stat.h>  
    #include<fcntl.h>  
    #include<unistd.h>
    
    int main()
    {
        
        int fd = open("log.txt", O_WRONLY|O_APPEND);//打开
        if(fd < 0)
        {
        
            perror("open");
            return 1;
        }
        
        //操作
        const char* byh = "Hello System Call!\n";
        write(fd, byh, strlen(byh));
        write(fd, byh, strlen(byh));                    
                                                          
        close(fd);//关闭                                  
                                                          
        return 0;                                         
    }

![请添加图片描述][77e5e5bd286a4a23ba6191e60f5a6305.png]

--------------------

## ? 3. 文件描述符fd ##

#include<stdio.h>  
    #include<sys/types.h>  
    #include<sys/stat.h>  
    #include<fcntl.h>  
      
    int main()  
    {
          
        int fd1 = open("log1.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
        int fd2 = open("log2.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
        int fd3 = open("log3.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
        int fd4 = open("log4.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
        int fd5 = open("log5.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
    
        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;  
    }

![请添加图片描述][0e4a4fe2908f4e318ee2ea8bb5debb40.png]  
我们说过返回小于 0 的数，则代表 open 失败，显示这里 open 都成功了。但是这里为什么不从 0 开始依次返回？—— 上面我们说过 C 程序运行起来，默认会打开三个文件(stdin、stdout、stderr)，所以 0, 1, 2 分别与之对应。

Linux进程默认情况下会有3个缺省打开的文件描述符，分别是标准输入0， 标准输出1， 标准错误2.

0,1,2对应的物理设备一般是：键盘，显示器，显示器  
![在这里插入图片描述][6c32b2135ac14fd7a001636995e55458.png]

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

--------------------

### ? 3.1 文件描述符的分配规则 ###

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unisty.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;
    }

![请添加图片描述][a6bb9ec8f30740199f8b9fd3f0682c4c.png]

每次给新文件分配的fd，是从fd\_array\[\]中找一个最小的、未被使用的作为新的fd.

这其实很好理解，打开的文件要和进程产生关联，就要线性遍历数组中找一个未被使用的下标，填入文件地址。

--------------------

## ? 4. 重定向原理 ##

#include<stdio.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    
    int main()
    {
        
        //close(0);
        close(1);
    
        int fd1 = open("log3.txt", O_CREAT|O_WRONLY, 0644);
        int fd2 = open("log4.txt", O_CREAT|O_WRONLY, 0644);
    
        printf("hello byh!: %d\n", fd1);
        printf("hello byh!: %d\n", fd2);
    
        fflush(stdout);
                                                           
        close(fd1);
        close(fd2);
    
        return 0;
    }

![请添加图片描述][3d3223ded9434f6a801193281162e58a.png]  
要想看到数据也很简单，在 close 之前 fflush 强制刷新即可，但这里要注意 fd1 和 fd2 对应 1 和 3，它们都是磁盘文件，printf 时，因为缓冲区没满，所以都在语言层的缓冲区，但是 fflush 之后，就会一次性的把两次数据都往 fd1 指向的文件中刷新。本来 printf 应该往显示器上输出，但 close 1，open 新文件，导致 1 的指向由显示器转换为磁盘，导致最终往文件里输出，本质重定向改变的是底层文件描述符下标指针的内容，上层是不知道的，这种技术叫做输出重定向。

虽然 stdout 和 stderr 对应的设备都是显示器，但是它们是两个独立的文件描述符，且作用却大不相同。这里虽然它们最终都往显示器上输出，但是重定向时，却只能对 stdout 重定向，因为底层改的是 1，没有影响 2

![在这里插入图片描述][6befedc820624b2f9faebb7539635deb.png]

--------------------

## 基础IO上总结 ##

*  如何理解—— 一切皆文件。
 *  进程在启动时，默认会打开 0, 1, 2，对应 C 语言上，就是 stdin, stdout, stderr。
 *  库函数的文件操作和系统调用的文件操作。
 *  FILE\* 和 fd。
 *  fd 本质是进程和文件之间对应关系的数组的下标，有了 fd，就可以找到，打开文件的所有细节。
 *  FILE\*，FILE 是一个结构体，它主要有两块重要的成员 \_fileno、缓冲区。
 *  数据在文件层面的流动过程。
 *  初步了解了重定向的原理和现象。

--------------------

[Link 1]: https://blog.csdn.net/m0_60338933?type=blog
[0c3f31bc6bb5460689d5e339f5299830.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/6bb53503f2004b33b10c648b7b682a33.jpeg
[773c16ffc82c493280ffcdcaceadff4a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bb7bd556bdac4c9491d9dfac730ed713.png
[a5748c37a0bb4aef947710c9008c7b1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/2567cfb8bf3d469dbc297031b2c5dd56.png
[162e58b73bc54191987083765d7b975c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/121ae5975903412c85222861171e3b98.png
[0eeea045dbee45239cf8b39bca4428d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b7a33c2906db4ddf9ee56321cb983228.png
[905467b55132448399c09a061ff6cf0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/2744e89b6e394c48a6787f72e687d9a9.png
[5fea9fef5a224b6fac5be155827c06ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/6e4e7f021eaa43f180273e5d43791263.png
[a908cb46b75c4577a6abbfbd0c3c110c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8aba60eb5e4b4060b53f8b75e2cc0d73.png
[77e5e5bd286a4a23ba6191e60f5a6305.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7107a98dc19c45698ecf090347257998.png
[0e4a4fe2908f4e318ee2ea8bb5debb40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c7b7436264ec47f8b76883daeaad1074.png
[6c32b2135ac14fd7a001636995e55458.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c8140c15ff544bf698139f83f3fb455d.png
[a6bb9ec8f30740199f8b9fd3f0682c4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0abc5c75484343a6bb77e11249d59600.png
[3d3223ded9434f6a801193281162e58a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f01e3240549649b9a75366d417b8bfb8.png
[6befedc820624b2f9faebb7539635deb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9596392f177948dbb87e43bad4eab086.png