Linux基础IO【文件理解与操作】

✨个人主页： Yohifo

���属专栏： Linux学习之旅

每篇一句： 图片来源

操作环境： CentOS 7.6 阿里云远程服务器

• Great minds discuss ideas. Average minds discuss events. Small minds discuss people.
  • 大智论道，中智论事，小智论人。

    ---

    文章目录

    • 前言
    • ️正文
    • • 1、文件理解
      • 2、C语言文件操作
      • • 2.1、文件打开
        • 2.2、文件关闭
        • 2.3、文件写入
        • 2.4、文件读取
        • 3、系统级文件操作
        • • 3.1、打开 open
          • • 3.1.1、函数理解
            • 3.1.2、位图demo
            • 3.2、关闭 close
            • 3.3、写入 write
            • 3.4、读取 read
            • 4、小结
            • • 4.1、高级语言文件操作的本质
              • 总结

                ---

                前言

                文件操作是 基础IO 学习的第一步，我们在 C语言 进阶中，就已经学习了文件相关操作，比如 fopen 和 fclose，语言层面只要会用就行，但对于系统学习者来说，还要清楚这些函数是如何与硬件进行交互的

                调用库函数进行文件操作时的流程

                ---

                ️正文

                1、文件理解

                先来通过几个问题来理解文件

                文件操作的本质是什么？

                • 语言层面的文件操作就是直接使用库函数，而事实上，文件操作是系统层面的问题，就像进程管理一样，系统也会通过 先描述，再组织 的方式对文件进行管理、操作

                  只有 C/C++ 这种偏底层的语言才有文件操作吗？

                  • 并不是，其他语言也支持文件操作，如 Java；在进行文件操作时，不同语言使用方法可能有所不同，但 本质上都是在调用系统级接口进行操作

                    文件由什么构成？一般文件放在哪里？

                    • 文件 = 内容 + 属性
                    • 未使用的文件位于 磁盘，而使用中的文件 属性 会被加载至内存中
                    • 本文讨论的是已被加载至内存文件的相关操作

                      系统是如何区分文件的？

                      • 文件可以同时被多次使用，OS 为了管理好文件，会像使用 task_struct 管理进程一样，通过 struct file 存储文件属性进行管理
                      • struct file 结构体包含了文件的各种属性和链接关系

                        文件是由谁打开的？

                        • 由用户创建进程，调用系统级接口，再交给 OS 完成文件打开任务，文件写入与读取时也是同理

                          总结： 真正的文件操作需要结合系统底层学习，而我们之前的文件操作都是 进程 与 OS 间的交互

                          ---

                          2、C语言文件操作

                          在学习 系统级文件操作 前，需要先回顾一下 C语言 中的文件操作

                          2.1、文件打开

                          FILE * fopen ( const char * filename, const char * mode );

                          通过文件名以指定打开方式，打开文件

                          打开方式(参数2)

                          • w 只写，如果文件不存在，会新建，文件写入前，会先清空内容
                          • a 追加，在文件末尾，对文件进行追加写入，追加前不会清空内容
                          • r 只读，打开已存在的文件进行读取，若文件不存在，会打开失败
                          • w+、a+、r+ 读写兼具，区别在于是否会新建文件，只有 r+ 不会新建

                            //打开文件进行操作//在当前目录中打开文件 log.txt//注意：同一个文件，可以同时多次打开FILE* fp1 = fopen("log.txt", "w");//只读FILE* fp2 = fopen("log.txt", "a");//追加FILE* fp3 = fopen("log.txt", "r");//只写，文件不存在会打开失败FILE* fp4 = fopen("log.txt", "w+");//可读可写FILE* fp5 = fopen("log.txt", "a+");//可读可追加FILE* fp6 = fopen("log.txt", "r+");//可读可写，文件不存在会打开失败

                            若文件打开失败，会返回空 NULL，可以在打开后判断是否成功

                            注意： 若参数1直接使用文件名，则此文件需要位于当前程序目录下，如果想指定目录存放，可以使用绝对路径

                            2.2、文件关闭

                            文件打开并使用后需要关闭，就像动态内存申请后需要释放一样

                            int fclose ( FILE * stream );

                            关闭已打开文件，只需通过 FILE* 指针进行操作即可

                            //对上面打开的文件进行关闭//无论以哪种方式打开，关闭方法都一样fclose(fp1);fclose(fp2);fclose(fp3);fclose(fp4);fclose(fp5);fclose(fp6);

                            注意： 只能对已打开的文件进行关闭，若文件不存在，会报错

                            2.3、文件写入

                            C语言 对于文件写入有这几种方式：fputc、fputs、fwrite、fprintf 和 snprintf

                            int fputc ( int character, FILE * stream );int fputs ( const char * str, FILE * stream );size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );int snprintf ( char * s, size_t n, const char * format, ... );

                            前几种方式比较简单，无非就是 逐字符写入、逐行写入 与 格式化写入，这里主要来介绍一下 snprintf

                            snprintf 是 sprintf 的优化版，增加了读取字符长度控制，更加安全

                            • 参数1：缓冲区，常写做 buffer 数组
                            • 参数2：缓冲区的大小
                            • 参数3：格式化输入，比如 "%d\n", 10

                              使用 snprintf 函数写入数据至缓冲区后，可以再次通过 fputs 函数，将缓冲区中的数据真正写入文件中

                              #include #include #define LOG "log.txt" //日志文件#define SIZE 32int main(){  FILE* fp = fopen(LOG, "w");  if(!fp)  {    perror("fopen file fail!"); //报错    exit(-1); //终止进程  }  char buffer[SIZE];  //缓冲区  int cnt = 5;  while(cnt--)  {    snprintf(buffer, SIZE, "%s\n", "Hello File!");  //写入数据至缓冲区    fputs(buffer, fp);  //将缓冲区中的内容写入文件中  }  fclose(fp);  fp = NULL;  return 0;}

                              得益于格式化控制，可以灵活地向日志文件中写入内容

                              2.4、文件读取

                              读取与写入配套出现

                              int fgetc ( FILE * stream );char * fgets ( char * str, int num, FILE * stream );size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );int fscanf ( FILE * stream, const char * format, ... );int sscanf ( const char * s, const char * format, ...);

                              可以使用 sscanf 按照一定的规则格式化读取字符串 s

                              #include int main(){  char s[] = "2023:3:24";  int arr[3];  char* buffer[4];  sscanf(s, "%d:%d:%d", arr, arr + 1, arr + 2);  printf("%d\n%d\n%d\n", arr[0], arr[1], arr[2]);  return 0;}

                              这个函数多用于 序列化与反序列化操作

                              关于更多 C语言 文件操作的知识 《C语言进阶——文件操作》

                              ---

                              3、系统级文件操作

                              回顾完 C语言 文件相关操作后，就可以开始系统级文件操作的学习了

                              3.1、打开 open

                              首先学习如何直接调用调用系统级函数 open 打开文件

                              #include #include #include int open(const char *pathname, int flags);int open(const char *pathname, int flags, mode_t mode);//可以修改权限

                              3.1.1、函数理解

                              返回值：不同于 FILE*，系统级文件打开函数返回类型为 int，即 文件描述符（ file descriptor ），文件打开失败返回 -1

                              文件描述符很重要，将在下篇文章 《重定向本质》 中讲解

                              参数1：pathname 待操作文件名，和 fopen 一样

                              参数2：flags 打开选项，open 使用的标记位的方式传递选项信号，用一个 int 至多可以表示 32 个选项

                              参数3：mode 权限设置，文件起始权限为 0666

                              主要就是参数2有点复杂，使用了 位图 的方式进行多参数传递

                              可以利用这个特性，写一个关于位图的小demo

                              3.1.2、位图demo

                              #include #include #define ONE 0x1#define TWO 0x2#define THREE 0x4void Test(int flags){  //模拟实现三种选项传递  if(flags & ONE)    printf("This is one\n");  if(flags & TWO)    printf("This is two\n");  if(flags & THREE)    printf("This is three\n");}int main(){  Test(ONE | TWO | THREE);  printf("-----------------------------------\n");  Test(ONE);  //位图使得选项传递更加灵活  return 0;}

                              函数 open 中的参数2正是位图，其参数有很多个，这里列举部分

                               O_RDONLY//只读 O_WRONLY//只写 O_APPEND//追加 O_CREAT//新建 O_TRUNC//清空

                              实际使用时，可以按照位图demo中的方式进行参数传递

                              #include #include #include #include #include #include #include  //write 的头文件#define LOG "log.txt" //日志文件#define SIZE 32int main(){  //三种参数组合，就构成了 fopen 中的 w  int fd = open(LOG, O_WRONLY | O_CREAT | O_TRUNC, 0666);//权限最好设置  if(fd == -1)  {    perror("open file fail1");    exit(-1);  }  const char* ps = "Hello System Call!\n";  int cnt = 5;  while(cnt--)    write(fd, ps, strlen(ps));  //不能将 '
                              假若文件不存在，open 中的参数3最好进行设置，否则创建出来的文件权限为随机值
                              ' 写入文件中  close(fd);  return 0;}

                              注意：

                              • 继承环境变量表后，umask 默认为 0002，当然也可以自定义
                              • w -> O_WRONLY | O_CREAT | O_TRUNC
                              • 通过系统级函数 write 写入字符串时，不要刻意加上 '\0'，因为对于系统来说，这也只是一个普通的字符（'\0' 作为字符串结尾只是 C语言 的规定）

                                C语言 中的 fopen 调用 open 函数，其中的选项对应关系如下

                                • a -> O_WRONLY | O_CREAT | O_APPEND
                                • r -> O_RDONLY

                                3.2、关闭 close

                                • ……

                                  所以只要我们想，使用 open 时，也能做到 只读方式 打开 不存在的文件，也不会报错，加个 O_CREAT 参数即可

                                  #include int close(int fildes);

                                  close 函数根据文件描述符关闭文件

                                  3.3、写入 write

                                  Linux 下一切皆文件

                                  包括这三个标准流： stdin、stdout、stderr

                                  它们的文件描述符依次为：0、1、2，也可以通过 close(1) 的方式，关闭标准流

                                  #include ssize_t write(int fildes, const void *buf, size_t nbyte);

                                  write 函数的返回值类型有点特殊，但使用方法与 fwrite 基本一致

                                  3.4、读取 read

                                  向文件中写入字符串，前面已经演示过了~

                                  #include ssize_t read(int fildes, void *buf, size_t nbyte);

                                  read 读取很淳朴，只支持指定字符数读取

                                  #include #include #include #include #include #include #include  //write 的头文件#define LOG "log.txt" //日志文件#define SIZE 1024int main(){  int fd = open("test.c", O_RDONLY);  if(fd == -1)  {    perror("open file fail1");    exit(-1);  }  int n = 50; //读取50个字符  char buffer[SIZE];  int pos = 0;  while(n--)  {    read(fd, (char*)buffer + pos, 1);    pos++;  }  printf("%s\n", buffer);  close(fd);  return 0;}

                                  文件读取时，同样是借助缓冲区进行读取

                                  4、小结

                                  读取 test.c 源文件中的 100 个字符

                                  这些系统级函数成功使用的前提是文件描述符合法

                                  ---

                                  4.1、高级语言文件操作的本质

                                  最后再来简单小结一下文件的本质（结合系统级函数）

                                  总结

                                  只要是在 Linux 平台中编写的程序，无论是 Java、Python、PHP 还是其他语言，在进行文件相关操作时，其文件操作函数都有对系统级函数进行封装，也就是说，要想与硬件（磁盘）打交道，必须经过 系统调用 -> OS -> 驱动 这条路线，无法直接与硬件进行交互

                                  ---

                                  如果你觉得本文写的还不错的话，期待留下一个小小的赞，你的支持是我分享的最大动力！

                                  如果本文有不足或错误的地方，随时欢迎指出，我会在第一时间改正

                                  ---

                                  相关文章推荐

                                  Linux【模拟实现简易版bash】

                                  Linux进程控制【进程程序替换】

                                  Linux进程控制【创建、终止、等待】

                                  ** =============== **

                                  Linux进程学习【进程地址】 Linux进程学习【环境变量】 Linux进程学习【进程状态】 Linux进程学习【基本认知】