【Linux从入门到精通】文件I/O操作（C语言vs系统调用）

﹏ヽ暗。殇╰゛Y 2024-04-22 22:19 25阅读 0赞

![48c60937b54543e59b3f98ad1c744276.gif][]

> **文章目录**
> 
> 一、C语言的文件IO相关函数操作
> 
> 1、1 fopen与fclose
> 
> 1、2 fwrite
> 
> 1、3 fprintf与fscanf
> 
> 1、4 fgets与fputs
> 
> 二、系统调用相关接口
> 
> 2、1 open与close
> 
> 2、2 write和read
> 
> 三、简易模拟实现cat指令
> 
> 四、总结
> 
> --------------------
> 
> **?♂️ 作者：@Ggggggtm ?♂️**
> 
> **? 专栏：Linux从入门到精通 ?**
> 
> **? 标题：文件操作?**
> 
>  **❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️**

> 本篇文章主要会讲解C语言的文件IO相关操作的函数，同时也会对Linux下的文件操作系统调用接口进行讲解。希望本篇文章会对你有所帮助。

## 一、C语言的文件IO相关函数操作 ##

### 1、1 fopen与fclose ###

> fopen() 函数原型：FILE \*fopen(const char \*filename, const char \*mode); 作用：打开一个文件，并返回一个文件指针。 参数：
> 
>  *  filename：要**打开的文件名（含路径）**。
>  *  mode：打开文件的模式，如 "r" 表示只读，"w" 表示写入（如果文件存在则清空内容），"a" 表示追加写入等。
> 
> 具体如下图：
> 
> ![a40c46ab126b4cb3ba1d58d4858f78c2.png][]

> fclose() 函数原型：int fclose(FILE \*stream); 作用：关闭一个打开的文件。 参数：
> 
>  *  stream：**要关闭的文件指针**。
> 
> 具体可结合下图理解：![305f0d9d0844428b84533348d559541b.png][]

> 我们知道使用 fopen 时需要添加索要打开文件的路径。当我们以w的方式进行打开时，该文件不存在会自动创建文件，具体代码如下图：
> 
>     #include<stdio.h>    
>         
>     int main()    
>     {    
>         FILE* fd = fopen("log.txt","w");    
>         if(fd==NULL)    
>         {    
>             perror("fopen");    
>         }    
>         
>         fclose(fd);  
>         
>         //while死循环完全是为了方便查看和观察
>         while(1)
>         {
>             sleep(1);
>         }                                                                                                                                        
>         return 0;    
>     }
> 
> 上述代码中，fopen中并没有添加路径，只有一个文件名字。那么能打开成功吗？其次是，当前目录下并没有 log.txt 文件，如果能打开成功，文件会被创建到哪里呢？我们带着这些疑问接着往下看。

> 我们不妨先观察一下运行结果，如下图：
> 
> ![ee71f4cf1f334b56a89e00db4cd91aa6.png][] 我们看到确实能够出创建出来，也是创建在了当前目录了！这是为什么呢？当一个程序运行起来后，会在内存中创建相应的数据结构，同时变成进程。该进程包含了当前所在的工作目录，且还有当前的可执行文件所在的目录。具体如下图：
> 
> ![39215795ff4549dface97c9248ba70d0.png][] 所以即使我们并没有添加路径，操作系统也会知道当前所在的路径。并且默认创建到当前的工作路径下。

### 1、2 fwrite ###

> fwrite的函数原型：size\_t fwrite(const void \*ptr, size\_t size, size\_t count, FILE \*stream)。用于将数据块按字节写入文件。参数：
> 
>  *  ptr：指向要写入的数据的指针。
>  *  size：要写入的每个数据项的字节数。
>  *  count：要写入的数据项的数量。
>  *  stream：目标文件的指针。
> 
> 我们也可看下图理解：

> 我们现在用fwrite向log.txt中写入，具体代码如下：
> 
>     #include<stdio.h>    
>     #include<string.h>
>     
>     int main()
>     {
>         FILE* fp = fopen("log.txt","w");
>         if(fp==NULL)
>         {
>             perror("fopen");
>         }
>        //进行文件操作
>        const char *s1 = "hello Linux\n"; 
>        fwrite(s1, strlen(s1), 1, fp);
>     
>       
>         fclose(fp);    
>         return 0;
>     }
> 
> 这里有一个问题：**在写入文件时，要不要把s1的‘\\0’写入呢？答案是不用。字符串结尾标志'\\0'只是C语言规定的。文件并不用遵守C语言的规则**！我们看运行结果：
> 
> ![8b750260901e4969ba8034bd333287a8.png][]
> 
> log.txt文件中确实被写入了。假如我们注释掉写入的代码，只是打开后直接关闭文件，结果会是什么呢？如下图：
> 
> ![152a25e401a94126a033d843fee42711.png][]
> 
> 文件内容为空了！！！为什么呢？原因是**以“w”的方式打开文件，就是在写入前会被清空文件内容**。

### 1、3 fprintf与fscanf ###

> fprintf() 函数原型：int fprintf(FILE \*stream, const char \*format, ...); 作用：向文件中按指定格式写入数据。 参数：
> 
>  *  stream：要写入的文件指针。
>  *  format：格式化字符串，类似于printf()函数的格式化参数。 返回值：成功写入的字符数，出错时返回负值。
> 
> fprintf与printf相比，fprintf第一个参数是FILE\* ，其他的都一样。只不过是输出到了指定的文件上。

> fscanf() 函数原型：int fscanf(FILE \*stream, const char \*format, ...); 作用：从文件中按指定格式读取数据。 参数：
> 
>  *  stream：要读取的文件指针。
>  *  format：格式化字符串，类似于scanf()函数的格式化参数。 返回值：成功读取并匹配的项目数量，出错或到达文件结尾时返回EOF。
> 
> fscanf() 与scanf() 相比，fscanf() 第一个参数是FILE\* ，其他的都一样。读取数据时，是从指定的文件上读取。

> 这里我们就举例说明fsacnf，我们想要把文件的内容读取并输出，代码如下：
> 
>     #include<stdio.h>    
>     #include<unistd.h>    
>     #include<string.h>    
>         
>     int main()    
>     {    
>         FILE* fp = fopen("log.txt","r");    
>         if(fp==NULL)    
>         {    
>             perror("fopen");    
>         }    
>             
>         char line[128];    
>         while(fscanf(fp,"%s",line) != EOF)    
>         {                                                                                                                                                        
>             printf("%s\n", line);    
>         }   
>         return 0;
>     }
> 
> 运行结果如下：
> 
> ![d7014d337a484a79b0bf70aa89bf51cb.png][]
> 
> **注意，当我们要读取内容是，要修改打开文件的方式，应该以“r”的方式打开文件。否则会出现意想不到的结果！！！**

### 1、4 fgets与fputs ###

> fgets() 函数原型：char \*fgets(char \*str, int n, FILE \*stream); 作用：从文件中读取一行字符串。 参数：
> 
>  *  str：要读取的字符串存放的缓冲区。
>  *  n：最多读取的字符数（包括换行符）。
>  *  stream：要读取的文件指针。 返回值：成功时返回str，失败或到达文件结尾时返回NULL。
> 
> 具体如下图：
> 
> ![458fddc8731e44eba294a33d4731f8c9.png][]

> fputs() 函数原型：int fputs(const char \*str, FILE \*stream); 作用：向文件中写入一个字符串。 参数：
> 
>  *  str：要写入的字符串。
>  *  stream：要写入的文件指针。 返回值：成功写入的字符数，出错时返回EOF。
> 
> 具体如下图：
> 
> ![8adee4cd1d084837b1c32231e5b76efc.png][]

> 我们结合下述实例来理解fgets和fputs的用法，代码如下：
> 
>     #include<stdio.h>    
>     #include<unistd.h>    
>     #include<string.h>    
>         
>     int main()    
>     {    
>         FILE* fp = fopen("log.txt","r");    
>         if(fp==NULL)    
>         {    
>             perror("fopen");    
>         }     
>         char line[64];
>         //fgets -> C -> s(string) -> 会自动在字符结尾添加\0
>         while(fgets(line, sizeof(line), fp) != NULL)                                                                                                             
>         {
>             //printf("%s", line);
>             fputs(line, stdout); //输出到屏幕上
>         }
>         fclose(fp);
>         return 0;
>     } 
>     
>     
> 
> 运行结果如下：![ad7686a2db6d4ed9a5efe8fd14ce1444.png][]

## 二、系统调用相关接口 ##

### 2、1 open与close ###

> open()函数：open函数用于打开文件并获取文件描述符。它接受一个文件路径和一组标志作为参数，并返回一个用于后续文件操作的文件描述符。函数原型：int open(const char \*pathname, int flags, mode\_t mode)。详细解释：
> 
>  *  函数说明：打开文件并获取文件描述符。
>  *  参数：
>     
>      *  pathname：要打开的文件路径。
>      *  flags：打开文件的标志，例如O\_RDONLY（只读）、O\_WRONLY（只写）、O\_RDWR（读写）等。
>      *  mode：在创建新文件时使用的权限位。
>  *  返回值：
>     
>      *  成功：返回一个非负整数，表示**文件描述符**。
>      *  失败：返回-1，并设置errno来指示错误。
> 
> 具体可结合下图理解：
> 
> ![7be3ad7141794a138491763189df5906.png][]
> 
> ![89b1f1672f044f0f89adebc0db022195.png][]
> 
> 有很多的选项，我们想要添加那个选项，只需要在第二个参数 按位与（‘|’） 上就行。为什么 按位与（‘|’）呢？这里涉及到了**位图**的知识。想要知道的可以去了解一下位图。

> close()函数：close函数用于关闭打开的文件。它接受文件描述符作为参数，并返回一个表示成功与否的状态值。 函数原型：int close(int fd)。详细解释：
> 
>  *  函数说明：关闭打开的文件。
>  *  参数：
>     
>      *  fd：要关闭的文件描述符。
>  *  返回值：
>     
>      *  成功：返回0。
>      *  失败：返回-1，并设置errno来指示错误。

> 我们通过如下实例来理解open和close。代码如下：
> 
>     #include<stdio.h>    
>     #include<unistd.h>    
>     #include<string.h>
>     #include<sys/types.h>
>     #include<sys/stat.h>
>     #include<fcntl.h>
>     
>         
>     int main()    
>     {    
>           int fd1 = open("log.txt", O_RDONLY);
>           int fd2 = open("log2.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666); //rw-rw-rw-
>           if(fd1 < 0 || fd2 < 0)
>           {
>               perror("open");                                                                                                                                  
>               return 1;
>           }
>           close(fd1);
>           close(fd2);
>     
>           return 0;
>     }
> 
> 运行结果如下：
> 
> ![1c484415fd614c8ea3a7a5d1e2125540.png][]
> 
> 确实打开成功了。为什么log2.txt与我们设置的权限并不相同呢？不要忘记了系统中还有umask掩码。
> 
> ![a7de8aa89fba4a08bf0d2f0db06cb984.png][]

### 2、2 write和read ###

> write()函数：write函数用于向文件中写入数据。它接受文件描述符、要写入的数据和字节数作为参数，并返回实际写入的字节数。函数原型：ssize\_t write(int fd, const void \*buf, size\_t count)。详细解释：
> 
>  *  函数说明：向文件中写入数据。
>  *  参数：
>     
>      *  fd：要写入的文件描述符。
>      *  buf：要写入的数据的缓冲区。
>      *  count：要写入的字节数。
>  *  返回值：
>     
>      *  成功：返回实际写入的字节数。
>      *  失败：返回-1，并设置errno来指示错误。

> read()函数：read函数从文件中读取数据。它接受文件描述符、缓冲区指针和要读取的字节数作为参数，并返回实际读取的字节数。函数原型：ssize\_t read(int fd, void \*buf, size\_t count)。详细解释：
> 
>  *  函数说明：从文件中读取数据。
>  *  参数：
>     
>      *  fd：要读取的文件描述符。
>      *  buf：用于存储读取数据的缓冲区。
>      *  count：要读取的最大字节数。
>  *  返回值：
>     
>      *  成功：返回实际读取的字节数。
>      *  失败：返回-1，并设置errno来指示错误。

> write和read用起来也相对简单。这里就不再举例详细解释说明了。

## 三、简易模拟实现cat指令 ##

> 我们知道，cat是打印出一个文件的内容。我们学习了文件操作后，就来简单的模拟实现一下cat指令。
> 
> cat指令不就是接受到文件，然后打印出文件的内容吗。这好像就是我们刚刚学了文件操作。我们直接看代码：
> 
>     #include<stdio.h>    
>     #include<unistd.h>    
>     #include<string.h>
>     int main(int argc,char* argv[])
>     {    
>         if(argc != 2)     
>         {    
>             printf("argv error!\n");    
>             return 1;    
>         }    
>         FILE *fp = fopen(argv[1], "r");     
>         if(fp == NULL)    
>         {    
>             //strerror    
>             perror("fopen");    
>             return 2;    
>         }    
>         
>         //按行读取                                                                                                                                               
>         char line[64];    
>         //fgets -> C -> s(string) -> 会自动在字符结尾添加\0 
>         // 将文件的内容打印到屏幕上   
>         while(fgets(line, sizeof(line), fp) != NULL)    
>         {    
>             //printf("%s", line);    
>             fprintf(stdout, "%s", line); //fprintf->stdout?
>         }
>         fclose(fp);
>         return 0;
>     }
> 
> 在运行时加上文件名就可以打印出文件的内容了。再加上我们之前讲到的创建子进程进行程序替换实现的简易版的shell，不就是实现了cat指令嘛！！！我们看输出结果：
> 
> ![e835e85a7b314bedbfd23b5165378fc8.png][]

## 四、总结 ##

> 本篇文章讲述了一系列的文件操作函数。其实我们学的C语言的文件操作函数，底层都是封装的系统调用的接口。因为我们对文件的写入和读取，不就是对硬盘的写入和读取吗！文件可是放在硬盘上的。语言想要访问硬件设备，必须通过操作系统！！！
> 
> 每套语言都是有自己的文件操作函数，底层都是封装的系统调用的接口。但是操作系统不只是有Linux，还有windows等等。那语言就是封装所有的操作系统的接口呗。只不过是在调用时会有选择判断。这样封装后，语言就有了跨平台性。

> 上文中有一个名词：**文件描述符**。我们并没有对此进行详解。**下篇文章会对此进行讲解**。这个也是一个重点！！！
> 
> 本片文章的讲解就到这里。感谢阅读ovo~

[48c60937b54543e59b3f98ad1c744276.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/cd0679e4790742b4af2b08ce31383f23.gif
[a40c46ab126b4cb3ba1d58d4858f78c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/11aae2581db044c79a7d608aa0dd88e9.png
[305f0d9d0844428b84533348d559541b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/8e3d6d9ccc134bc7bdf789ec63a7e8cb.png
[ee71f4cf1f334b56a89e00db4cd91aa6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/ffe9c7b9cb5a4493b4a18151b4d793e2.png
[39215795ff4549dface97c9248ba70d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/e986b54d351744a7880f742e38190c48.png
[8b750260901e4969ba8034bd333287a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d8d88608d8994b439d9068abe2ac3d6e.png
[152a25e401a94126a033d843fee42711.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/34560c9c612b488795d00499b273fc1e.png
[d7014d337a484a79b0bf70aa89bf51cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/fac348a362a349ef87e0ef23652f9d2e.png
[458fddc8731e44eba294a33d4731f8c9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/58c980631dd14c9da384e5a61662ecae.png
[8adee4cd1d084837b1c32231e5b76efc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/3e565207bb564bac82ee3cbcca9bf074.png
[ad7686a2db6d4ed9a5efe8fd14ce1444.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/60d0c72fd6454a69b476c86d1d8306a3.png
[7be3ad7141794a138491763189df5906.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/12b907d6ffc5445bb010990f9b2bfcf8.png
[89b1f1672f044f0f89adebc0db022195.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/f16de3f009444199aebc583c9c5b1a7e.png
[1c484415fd614c8ea3a7a5d1e2125540.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/ae6fe18010ac4d3fbbd4f79c97218399.png
[a7de8aa89fba4a08bf0d2f0db06cb984.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/74469896142d4f839f15a5e42ac02fa0.png
[e835e85a7b314bedbfd23b5165378fc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/20ea6030001d4142b2df4e3da2fa3068.png