Linux系统编程(二):标准 I/O 库(下)

2023-12-15 20:35:50

参考引用

1. 标准 I/O 库简介

  • 标准 I/O 库是指:标准 C 库中用于文件 I/O 操作(如:读、写文件等)相关的一系列库函数的集合
    • 标准 I/O 库函数相关的函数定义都在头文件 <stdio.h> 中
    • 标准 I/O 库函数构建于文件 I/O(open()、read()、write()、lseek()、close()等)这些系统调用之上,如:标准 I/O 库函数 fopen() 就利用系统调用 open() 来执行打开文件的操作

    为什么需要标准 I/O 库?直接使用文件 I/O 系统调用不是更好吗?

    • 设计库函数是为了提供比底层系统调用更为方便、好用的调用接口,虽然标准 I/O 构建于文件 I/O 之上,但标准 I/O 却有它自己的优势

  • 标准 I/O 和文件 I/O 的区别如下
    • 虽然标准 I/O 和文件 I/O 都是 C 语言函数,但是标准 I/O 是标准 C 库函数,而文件 I/O 则是 Linux 系统调用
    • 标准 I/O 是由文件 I/O 封装而来,标准 I/O 内部实际上是调用文件 I/O 来完成实际操作的
    • 可移植性:标准 I/O 相比于文件 I/O 具有更好的可移植性
      • 通常对于不同的操作系统,其内核向应用层提供的系统调用往往都是不同,如:系统调用的定义、功能、参数列表、返回值等往往都不同
      • 而对于标准 I/O 来说,由于很多操作系统都实现了标准 I/O 库,标准 I/O 库在不同的操作系统之间其接口定义几乎是一样的,所以标准 I/O 在不同操作系统之间相比于文件 I/O 具有更好的可移植性
    • 性能、效率:标准 I/O 库在用户空间维护了自己的 stdio 缓冲区,所以标准 I/O 是带有缓存的,而文件 I/O 在用户空间是不带有缓存的,所以在性能、效率上,标准 I/O 要优于文件 I/O

2. FILE 指针

  • 所有文件 I/O 函数(open()、read()、write()、lseek()等)都是围绕文件描述符进行的,当调用 open()函数打开一个文件时,即返回一个文件描述符 fd,然后该文件描述符就用于后续的 I/O 操作
  • 而对于标准 I/O 库函数来说,它们的操作是围绕 FILE 指针进行的,当使用标准 I/O 库函数打开或创建一个文件时,会返回一个指向 FILE 类型对象的指针(FILE *),使用该 FILE 指针与被打开或创建的文件相关联,然后该 FILE 指针就用于后续的标准 I/O 操作
  • FILE 指针的作用相当于文件描述符,FILE 指针用于标准 I/O 库函数中,而文件描述符则用于文件 I/O 系统调用中
  • FILE 是一个结构体数据类型,它包含了标准 I/O 库函数为管理文件所需要的所有信息,包括用于实际 I/O 的文件描述符、指向文件缓冲区的指针、缓冲区的长度、当前缓冲区中的字节数以及出错标志等
    • FILE 数据结构定义在标准 I/O 库函数头文件 stdio.h 中

3. 标准输入、标准输出和标准错误

  • 用户通过标准输入设备与系统进行交互,进程将从标准输入 (stdin) 文件中得到输入数据,将正常输出数据(如:printf 打印输出)输出到标准输出(stdout) 文件,而将错误信息(如:函数调用报错)输出到标准错误 (stderr) 文件
    • 标准输出文件和标准错误文件都对应终端的显示器,而标准输入文件则对应于键盘
  • 每个进程启动之后都会默认打开标准输入、标准输出以及标准错误,得到三个文件描述符,即 0(标准输入)、1(标准输出)、2(标准错误),在应用编程中可以使用宏 STDIN_FILENO、STDOUT_FILENO 和 STDERR_FILENO 分别代表 0、1、2,这些宏定义在 unistd.h 头文件中
    #define STDIN_FILENO 0 /* Standard input. */
    #define STDOUT_FILENO1 /* Standard output. */
    #define STDERR_FILENO2 /* Standard error output. */
    
  • 0、1、2 是文件描述符,只能用于文件 I/O,标准 I/O 中,需围绕 FILE 类型指针进行,在 stdio.h 头文件定义
    // struct _IO_FILE 结构体就是 FILE 结构体,使用 typedef 进行了重命名
    extern struct _IO_FILE *stdin; /* Standard input stream. */
    extern struct _IO_FILE *stdout; /* Standard output stream. */
    extern struct _IO_FILE *stderr; /* Standard error output stream. */
    
    /* C89/C99 say they're macros. */
    #define stdin stdin
    #define stdout stdout
    #define stderr stderr
    

4. 打开文件 fopen()、关闭文件 fclose()

  • 标准 I/O 中,将使用库函数 fopen() 打开或创建文件
    #include <stdio.h>
    
    // path:参数 path 指向文件路径,可以是绝对路径或相对路径
    // mode:参数 mode 指定了对该文件的读写权限,是一个字符串
    // 返回值:调用成功返回一个指向 FILE 类型对象的指针(FILE *)
    FILE *fopen(const char *path, const char *mode);
    
  • 参数 mode 字符串类型,可取值如下
    在这里插入图片描述

在这里插入图片描述

  • 虽然调用 fopen()函数新建文件时无法手动指定文件的权限,但却有一个默认值
    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH (0666)
    
  • 调用 fclose() 库函数可以关闭一个由 fopen() 打开的文件
    #include <stdio.h>
    
    // 参数 stream 为 FILE 类型指针,调用成功返回 0;失败将返回 EOF(也就是-1)
    int fclose(FILE *stream);
    

5. 读文件和写文件

  • 可以使用 fread() 和 fwrite() 库函数对文件进行读、写操作
    #include <stdio.h>
    
    /*  
        ptr:fread() 将读取到的数据存放在参数 ptr 指向的缓冲区中
        size:fread() 从文件读取 nmemb 个数据项,每一个数据项大小为 size 个字节,所以总共读取 nmemb * size 个字节数据
        nmemb:参数 nmemb 指定了读取数据项的个数
        stream:FILE 指针
    */
    size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    /*  
        ptr:将参数 ptr 指向的缓冲区中的数据写入到文件中
        size:参数 size 指定了每个数据项的字节大小,与 fread() 函数的 size 参数意义相同
        nmemb:参数 nmemb 指定了写入的数据项个数,与 fread() 函数的 nmemb 参数意义相同
        stream:FILE 指针
    */
    size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
    

5.1 使用 fwrite() 将数据写入到文件中

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char buff[] = "Hello World!\n";
    FILE *fp = NULL;

    if ((fp = fopen("./test_file", "w")) == NULL) {
        perror("fopen error");
        exit(-1);
    }   

    printf("open success\n");

    if (fwrite(buff, 1, sizeof(buff), fp) < sizeof(buff)) {
        printf("fwrite error\n");
        fclose(fp);
        exit(-1);
    }   

    printf("write success\n");

    fclose(fp);
    exit(0);
}
$ gcc fw.c -o fw
$ ./fw 
open success
write success

$ cat test_file 
Hello World!

5.2 使用 fread() 从文件中读取数据

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char buf[50] = {0};
    FILE *fp = NULL;
    int size;

    /* 只读方式打开文件 */
    if ((fp = fopen("./test_file", "r")) == NULL) {
        perror("fopen error");
        exit(-1);
    }   
    printf("文件打开成功!\n");

    /* 读取 12 * 1=12 个字节的数据 */
    if ((size = fread(buf, 1, 12, fp)) < 12) {
        if (ferror(fp)) {  //使用 ferror 判断是否是发生错误
            printf("fread error\n");
            fclose(fp);
            exit(-1);
        }   

        /* 如果未发生错误则意味着已经到达了文件末尾 */
    }   
    printf("成功读取%d 个字节数据: %s\n", size, buf);

    /* 关闭文件 */
    fclose(fp);
    exit(0);
}
$ gcc fr.c -o fr
$ ./fr
文件打开成功!
成功读取12 个字节数据: Hello World!

$ cat test_file 
Hello World!

6. fseek 定位

  • 库函数 fseek() 的作用类似系统调用 lseek(),用于设置文件读写位置偏移量
    • 调用库函数 fread()、fwrite() 读写文件时,文件的读写位置偏移量会自动递增,使用 fseek() 可手动设置文件当前的读写位置偏移量
    #include <stdio.h>
    
    // stream:FILE 指针
    // offset:与 lseek() 函数的 offset 参数意义相同
    // whence:与 lseek() 函数的 whence 参数意义相同
    int fseek(FILE *stream, long offset, int whence);
    

6.1 使用 fseek() 调整文件读写位置

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    FILE *fp = NULL;
    char rd_buf[100] = {0};
    char wr_buf[] = "www.baidu.com\n";
    int ret;

    /* 打开文件 */
    if ((fp = fopen("./test_file", "w+")) == NULL) {
        perror("fopen error");
        exit(-1);
    }   
    printf("open seccess\n");

    /* 写文件 */
    if (fwrite(wr_buf, 1, sizeof(wr_buf), fp) < sizeof(wr_buf)) {
        printf("fwrite error\n");
        fclose(fp);
        exit(-1);
    }   
    printf("write success\n");
    
    /* 将读写位置移动到文件头部 */
    if (fseek(fp, 0, SEEK_SET) < 0) {
        perror("fseek error\n");
        fclose(fp);
        exit(-1);
    }   

    /* 读文件 */
    if ((ret = fread(rd_buf, 1, sizeof(wr_buf), fp)) < sizeof(wr_buf)) {
        printf("fread error\n");
        fclose(fp);
        exit(-1);
    }   
    printf("成功读取 %d 个字节数据: %s\n", ret, rd_buf);

    /* 关闭文件 */
    fclose(fp);
    exit(0);
}
$ gcc fseek.c -o fseek
$ ./fseek 
open seccess
write success
成功读取 14 个字节数据: www.baidu.com

7. ftell() 函数

  • 库函数 ftell() 可用于获取文件当前的读写位置偏移量
    #include <stdio.h>
    
    // 参数 stream 指向对应的文件,函数调用成功将返回当前读写位置偏移量;调用失败将返回 -1
    long ftell(FILE *stream);
    

7.1 使用 fseek() 和 ftell() 获取文件大小

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    FILE *fp = NULL;
    int ret;

    /* 打开文件 */
    if ((fp = fopen("./testApp.c", "r")) == NULL) {
        perror("fopen error");
        exit(-1);
    }
    printf("open success\n");

    /* 将读写位置移动到文件末尾 */
    if (fseek(fp, 0, SEEK_END) < 0>) {
        perror("fseek error");
        fclose(fp);
        exit(-1);
    }

    /* 获取当前位置偏移量,也就得到了 testApp.c 整个文件的大小 */
    if ((ret = ftell(fp)) < 0) {
        perror("ftell error");
        fclose(fp);
        exit(-1);
    }   
    printf("file size: %d\n", ret);

    /* 关闭文件 */
    fclose(fp);
    exit(0);
}
$ gcc ftell.c -o ftell
$ ./ftell 
open success
file size: 13

8. 检查或复位状态

8.1 feof() 函数

  • 库函数 feof() 用于测试参数 stream 所指文件的 end-of-file 标志
    • 如果 end-of-file 标志被设置了,则调用 feof() 函数将返回一个非零值
    • 如果 end-of-file 标志没有被设置,则返回 0
    #include <stdio.h>
    
    int feof(FILE *stream);
    
    // 当文件的读写位置移动到了文件末尾时,end-of-file 标志将会被设置
    if (feof(file)) {
        /* 到达文件末尾 */
    }
    else {
        /* 未到达文件末尾 */
    }
    

8.2 ferror() 函数

  • 库函数 ferror() 用于测试参数 stream 所指文件的错误标志
    • 如果错误标志被设置了,则调用 ferror() 函数将返回一个非零值
    • 如果错误标志没有被设置,则返回 0
    #include <stdio.h>
    
    int ferror(FILE *stream);
    
    // 当对文件的 I/O 操作发生错误时,错误标志将会被设置
    if (ferror(file)) {
        /* 发生错误 */
    }
    else {
        /* 未发生错误 */
    }
    

8.3 clearerr() 函数

  • 库函数 clearerr() 用于清除 end-of-file 标志和错误标志
    • 当调用 feof() 或 ferror() 校验这些标志后,通常需要清除这些标志,避免下次校验时使用到的是上一次设置的值,此时可以手动调用 clearerr() 函数清除标志
    • 对于 end-of-file 标志,除使用 clearerr() 显式清除外,当调用 fseek() 成功时也会清除文件的 end-of-file 标志
    #include <stdio.h>
    
    void clearerr(FILE *stream);
    
  • 示例
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    FILE *fp = NULL;
    char buf[20] = {0};

    /* 打开文件 */
    if ((fp = fopen("./testApp.c", "r")) == NULL) {
        perror("fopen error");
        exit(-1);
    }
    printf("文件打开成功!\n");

    /* 将读写位置移动到文件末尾 */
    if (fseek(fp, 0, SEEK_END) < 0) {
        perror("fseek error");
        fclose(fp);
        exit(-1);
    }

    /* 读文件 */
    if (fread(buf, 1, 10, fp) < 10) {
        if (feof(fp))
            printf("end-of-file 标志被设置, 已到文件末尾!\n");

        clearerr(fp);  // 清除标志
    }

    /* 关闭文件 */
    fclose(fp);
    exit(0);
}

9. 格式化 I/O

9.1 格式化输出

  • C 库函数提供了 5 个格式化输出函数,包括:printf()、fprintf()、dprintf()、sprintf()、snprintf()
    #include <stdio.h>
    
    int printf(const char *format, ...);
    
    int fprintf(FILE *stream, const char *format, ...);
    int dprintf(int fd, const char *format, ...);
    
    int sprintf(char *buf, const char *format, ...);
    int snprintf(char *buf, size_t size, const char *format, ...);
    
  • 这 5 个函数都是可变参函数,它们都有一个共同的参数 format,这是一个字符串,称为格式控制字符串,用于指定后续的参数如何进行格式转换,所以才把这些函数称为格式化输出
    • printf() 函数用于将格式化数据写入到标准输出
    printf("Hello World!\n");
    printf("%d\n", 5);
    
    • dprintf() 和 fprintf() 函数用于将格式化数据写入到指定的文件中,两者不同之处在于,fprintf() 使用 FILE 指针指定对应的文件,而 dprintf()则使用文件描述符 fd 指定对应的文件
    fprintf(stderr, "Hello World!\n");
    fprintf(stderr, "%d\n", 5);
    
    dprintf(STDERR_FILENO, "Hello World!\n");
    dprintf(STDERR_FILENO, "%d\n", 5);
    
    • sprintf()、snprintf() 函数可将格式化的数据存储在用户指定的缓冲区 buf 中
    char buf[100];
    sprintf(buf, "Hello World!\n");
    
    // 一般会使用这个函数进行格式化转换,并将转换后的字符串存放在缓冲区中
    // 如:将数字 100 转换为字符串 "100",将转换后得到的字符串存放在 buf 中
    // sprintf() 函数会在字符串尾端自动加上一个字符串终止字符 '\0'
    char buf[20] = {0};
    sprintf(buf, "%d", 100);
    

    sprintf() 函数可能会造成由参数 buf 指定的缓冲区溢出,因为缓冲区溢出会造成程序不稳定甚至安全隐患,为解决这个问题,引入 snprintf() 函数,在该函数中,使用参数 size 显式的指定缓冲区的大小

    • 如果写入到缓冲区的字节数大于参数 size 指定的大小,超出的部分将会被丢弃
    • 如果缓冲区空间足够大,snprintf() 函数就会返回写入到缓冲区的字符数

9.2 格式控制字符串 format:输出

  • 格式控制字符串由两部分组成:普通字符(非 % 字符)和转换说明
    • 普通字符会进行原样输出,每个转换说明都会对应后续的一个参数,通常有几个转换说明就需要提供几个参数(除固定参数之外的参数),使之一一对应,用于控制对应的参数如何进行转换
    printf("转换说明 1 转换说明 2 转换说明 3", arg1, arg2, arg3);
    
  • 每个转换说明都是以 % 字符开头,其格式如下所示(使用 [] 括起来的部分是可选的)
    /*
        flags:标志,用于规定输出样式,可包含 0 个或多个标志
        width:输出最小宽度,表示转换后输出字符串的最小宽度
        precision:精度,前面有一个点号 "."
        length:长度修饰符
        type:转换类型,指定待转换数据的类型
    */
    %[flags][width][.precision][length]type
    
9.2.1 type 类型
  • type 用于指定输出数据的类型,type 字段使用一个字符(字母字符)来表示
    在这里插入图片描述

在这里插入图片描述

9.2.2 flags 样式标志
  • flags 规定输出样式,% 后面可以跟 0 个或多个以下标志
    在这里插入图片描述

在这里插入图片描述

9.2.3 width 输出宽度
  • 最小的输出宽度,用十进制数来表示输出的最小位数
    • 若实际的输出位数大于指定的输出的最小位数,则以实际的位数进行输出
    • 若实际的位数小于指定输出的最小位数,则可按照指定的 flags 标志补 0 或补空格
      在这里插入图片描述
9.2.4 precision 精度
  • 精度字段以点号 “.” 开头,后跟一个十进制正数,可取值如下
    在这里插入图片描述

在这里插入图片描述

9.2.5 length 长度修饰符
  • 长度修饰符指明待转换数据的长度,因为 type 字段指定的的类型只有 int、unsigned int 以及 double 等几种数据类型,但是 C 语言内置的数据类型不止这几种,如:16bit 的 short、unsigned short,8bit 的 char、unsigned char,64bit 的 long long 等,为了能够区别不同长度的数据类型,于是长度修饰符(length)应运而生
  • length 长度修饰符也是使用字符(字母字符)来表示,结合 type 字段以确定不同长度的数据类型
    printf("%hd\n", 12345);   // 将数据以 short int 类型进行转换
    printf("%ld\n", 12345);   // 将数据以 long int 类型进行转换
    printf("%lld\n", 12345);  // 将数据以 long long int 类型进行转换
    

在这里插入图片描述

9.3 格式化输入

  • C 库函数提供了 3 个格式化输入函数,包括:scanf()、fscanf()、sscanf()
    #include <stdio.h>
    
    int scanf(const char *format, ...);
    int fscanf(FILE *stream, const char *format, ...);
    int sscanf(const char *str, const char *format, ...);
    
    • 这 3 个格式化输入函数也是可变参函数,它们都有一个共同的参数 format,同样也称为格式控制字符串,用于指定输入数据如何进行格式转换
    • scanf() 函数可将用户输入(标准输入)的数据进行格式化转换
      • 当程序中调用 scanf() 的时候,终端会被阻塞,等待用户输入数据,此时可以通过键盘输入一些字符,如:数字、字母或者其它字符,输入完成按回车即可
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    
    • fscanf() 函数从 FILE 指针指定文件中读取数据,并将数据进行格式化转换
      • 标准输入文件的数据就是用户输入的数据,如:通过键盘输入的数据
    int a, b, c;
    fscanf(stdin, "%d %d %d", &a, &b, &c);
    
    • sscanf() 函数从参数 str 所指向的字符串中读取数据,并将数据进行格式化转换
    char *str = "5454 hello";
    char buf[10];
    int a;
    
    sscanf(str, "%d %s", &a, buf);
    

9.4 格式控制字符串 format:输入

  • format 字符串包含一个或多个转换说明,每一个转换说明都是以百分号 “%”,转换说明格式如下
    /*
        width:最大字符宽度
        length:长度修饰符,与格式化输出函数的 format 相同
        type:指定输入数据的类型
    */
    %[*][width][length]type
    %[m][width][length]type
    
  • % 后面可选择性添加星号 * 或字母 m
    • 如果添加了星号*,格式化输入函数会按照转换说明的指示读取输入,但是丢弃输入,意味着不需要对转换后的结果进行存储,所以也就不需要提供相应的指针参数
    • 如果添加了 m,它只能与 %s、%c 以及 %[ 一起使用,调用者无需分配相应的缓冲区来保存格式转换后的数据,原因在于添加了 m,这些格式化输入函数内部会自动分配足够大小的缓冲区,并将缓冲区的地址值通过与该格式转换相对应的指针参数返回出来,该指针参数应该是指向 char* 变量的指针。随后,当不再需要此缓冲区时,调用者应调用 free() 函数来释放此缓冲区
    char *buf;
    
    scanf("%ms", &buf);
    ......
    
    free(buf);
    
9.4.1 type 类型
  • 此 type 字段与格式化输出函数中的 format 参数的 type 字段是同样的意义,用于指定输入数据的类型
    在这里插入图片描述

在这里插入图片描述

9.4.2 width 最大字符宽度
  • 是一个十进制表示的整数,用于指定最大字符宽度,当达到此最大值或发现不匹配的字符时(以先发生者为准),字符的读取将停止。大多数 type 类型会丢弃初始的空白字符,并且这些丢弃的字符不会计入最大字符宽度。对于字符串转换来说,scanf() 会在字符串末尾自动添加终止符 “\0”,最大字符宽度中不包括此终止符
    scanf("%4s", buf);  // 匹配字符串,字符串长度不超过 4 个字符
    // 用户输入 abcdefg,按回车,那么只能将 adcd 作为一个字符串存储在 buf 数组中
    
9.4.3 length 长度修饰符
  • 与格式化输出函数的格式控制字符串 format 中的 length 字段意义相同,用于对 type 字段进行修饰,扩展识别更多不同长度的数据类型
    scanf("%hd", var);   // 匹配 short int 类型数据
    scanf("%hhd", var);  // 匹配 signed char 类型数据
    scanf("%ld", var);   // 匹配 long int 类型数据
    scanf("%f", var);    // 匹配 float 类型数据
    scanf("%lf", var);   // 匹配 double 类型数据
    scanf("%Lf", var);   // 匹配 long double 类型数据
    

在这里插入图片描述

10. I/O 缓冲

  • 1、首先,应用程序调用标准 I/O 库函数将用户数据写入到 stdio 缓冲区中,stdio 缓冲区是由 stdio 库所维护的用户空间缓冲区
  • 2、然后,针对不同的缓冲模式,当满足条件时,stdio 库会调用文件 I/O(系统调用 I/O)将 stdio 缓冲区中缓存的数据写入到内核缓冲区中,内核缓冲区位于内核空间
  • 3、最终,由内核向磁盘设备发起读写操作,将内核缓冲区中的数据写入到磁盘(或者从磁盘设备读取数据到内核缓冲区)
    在这里插入图片描述

10.1 文件 I/O 的内核缓冲

  • read() 和 write() 系统调用在进行文件读写操作时并不会直接访问磁盘设备,而是仅仅在用户空间缓冲区和内核缓冲区之间复制数据。如:调用 write() 函数将 5 个字节数据从用户空间内存拷贝到内核空间的缓冲区中
    write(fd, "Hello", 5);  // 写入 5 个字节数据
    
  • 调用 write() 后仅仅只是将这 5 个字节数据拷贝到了内核空间的缓冲区中,拷贝完成之后函数就返回了,在后面的某个时刻,内核会将其缓冲区中的数据写入(刷新)到磁盘设备中
    • 由此可知,系统调用 write() 与磁盘操作并不是同步的,write() 函数并不会等待数据真正写入到磁盘之后再返回
    • 如果在此期间,其它系统调用如 read() 函数读取该文件的这几个字节数据,那么内核将自动从缓冲区中读取这几个字节数据返回给应用程序

    对于读文件而言亦是如此,内核会从磁盘设备中读取文件数据并存储到内核缓冲区中,当调用 read() 读取数据时,read() 调用将从内核缓冲区中读取数据,直至把缓冲区中的数据读完,这时,内核会将文件的下一段内容读入到内核缓冲区中进行缓存,把这个内核缓冲区就称为文件 I/O 的内核缓冲


  • 文件 I/O 的内核缓冲区的设计目的?
    • 1. 提高文件 I/O 的速度和效率(使得系统调用 read()、write()的操作更为快速)
      • 不需要等待磁盘操作(将数据写入到磁盘或从磁盘读取出数据),磁盘操作通常是比较缓慢的
    • 2. 减少内核操作磁盘的次数
      • 如:线程 1 调用 write() 向文件写入 “abcd”,线程 2 也调用 write() 向文件写入 “1234”,这样,数据 “abcd” 和 “1234” 都被缓存在内核缓冲区中,稍后内核会将它们一起写入磁盘中,只发起一次磁盘操作请求

    文件 I/O 的内核缓冲区自然是越大越好,内核会分配尽可能多的内核来作为文件 I/O 的内核缓冲区,但受限于物理内存的总量,操作越大的文件也要依赖于更大空间的内核缓冲区


10.2 刷新文件 I/O 的内核缓冲区

  • 强制将文件 I/O 内核缓冲区中缓存的数据写入(刷新)到磁盘设备中,对于某些应用程序来说是很有必要的
    • 例如,应用程序在进行某操作之前,必须要确保前面步骤调用 write() 写入到文件的数据已经真正写入到了磁盘中,诸如一些数据库的日志进程
    • 在 Ubuntu 系统下拷贝文件到 U 盘时:文件拷贝完成之后,通常在拔掉 U 盘之前,需要执行 sync 命令进行同步操作,这个同步操作其实就是将文件 I/O 内核缓冲区中的数据更新到 U 盘硬件设备,所以如果在没有执行 sync 命令时拔掉 U 盘,很可能就会导致拷贝到 U 盘中的文件遭到破坏
10.2.1 控制文件 I/O 内核缓冲的系统调用
  • fsync() 函数

    • 系统调用 fsync() 将参数 fd 所指文件的内容数据和元数据写入磁盘,只有在对磁盘设备的写入操作完成之后,fsync() 函数才会返回
    • 元数据并不是文件内容本身的数据,而是一些用于记录文件属性相关的数据信息,如:文件大小、时间戳、权限等等信息,这里统称为文件的元数据,这些信息也是存储在磁盘设备中的
    #include <unistd.h>
    
    int fsync(int fd);
    
    • 示例
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    
    #define BUF_SIZE 4096
    #define READ_FILE "./rfile"
    #define WRITE_FILE "./wfile"
    
    static char buf[BUF_SIZE];
    
    int main(void) {
        int rfd, wfd;
        size_t size;
    
        /* 打开源文件 */
        rfd = open(READ_FILE, O_RDONLY);
        if (rfd < 0) {
            perror("open error");
            exit(-1);
        }
    
        /* 打开目标文件 */
        wfd = open(WRITE_FILE, O_WRONLY | O_CREAT | O_TRUNC, 0664);
        if (wfd < 0) {
            perror("open error");
            exit(-1);
        }
    
        /* 拷贝数据 */
        while((size = read(rfd, buf, BUF_SIZE)) > 0)
            write(wfd, buf, size);
    
        /* 对目标文件执行 fsync 同步 */
        fsync(wfd);
    
        /* 关闭文件退出程序 */
        close(rfd);
        close(wfd);
        exit(0);
    }
    
  • fdatasync() 函数

    • 系统调用 fdatasync()与 fsync()类似,不同之处在于 fdatasync() 仅将参数 fd 所指文件的内容数据写入磁盘,并不包括文件的元数据
    #include <unistd.h>
    
    int fdatasync(int fd);
    
  • sync() 函数

    • 系统调用 sync() 会将所有文件 I/O 内核缓冲区中的文件内容数据和元数据全部更新到磁盘设备中,该函数没有参数、也无返回值,意味着它不是对某一个指定的文件进行数据更新,而是刷新所有文件 I/O 内核缓冲区
    #include <unistd.h>
    
    void sync(void);
    
10.2.2 控制文件 I/O 内核缓冲的标志
  • O_DSYNC 标志
    • 在调用 open() 函数时,指定 O_SYNC 标志,使得每个 write() 调用都会自动将文件内容数据和元数据刷新到磁盘设备中,其效果类似于在每个 write() 调用之后调用 fsync() 函数进行数据同步
    fd = open(filepath, O_WRONLY | O_SYNC);
    

在程序中频繁调用 fsync()、fdatasync()、sync()(或者调用 open 时指定 O_DSYNC 或 O_SYNC 标志)对性能的影响极大,大部分的应用程序是没有这种需求的

10.3 直接 I/O:绕过内核缓冲

  • Linux 允许应用程序在执行文件 I/O 操作时绕过内核缓冲区,从用户空间直接将数据传递到文件或磁盘设备,把这种操作也称为直接 I/O(direct I/O)或裸 I/O(raw I/O)

    • 例如,某应用程序的作用是测试磁盘设备的读写速率,那么在这种应用需要下,就需要保证 read/write 操作是直接访问磁盘设备,而不经过内核缓冲
    • 对于大多数应用程序而言,使用直接 I/O 可能会大大降低性能
      • 直接 I/O 只在一些特定的需求场合,如:磁盘速率测试工具、数据库系统等
    • 可针对某一文件或块设备执行直接 I/O,需要在调用 open() 函数打开文件时指定 O_DIRECT 标志
    fd = open(filepath, O_WRONLY | O_DIRECT);
    
  • 因为直接 I/O 涉及到对磁盘设备的直接访问,所以在执行直接 I/O 时,必须要遵守三个对齐限制要求

    • 应用程序中用于存放数据的缓冲区,其内存起始地址必须以块大小的整数倍进行对齐
    • 写文件时,文件的位置偏移量必须是块大小的整数倍
    • 写入到文件的数据大小必须是块大小的整数倍
  • 以上所说的块大小指的是磁盘设备的物理块大小,常见的块大小包括 512 字节、1024 字节、2048 以及 4096 字节,如何确定磁盘分区的块大小?通常,Ubuntu 系统的根文件系统挂载在 /dev/sda1 磁盘分区下

    $ sudo tune2fs -l /dev/sda1 | grep "Block size"
    Block size:               4096
    

10.4 stdio 缓冲

  • 标准 I/O 是 C 语言标准库函数,而文件 I/O 是系统调用,虽然标准 I/O 是在文件 I/O 基础上进行封装而实现,但在效率、性能上,标准 I/O 要优于文件 I/O,原因在于标准 I/O 维护了自己的缓冲区,称为 stdio 缓冲区
    • 文件 I/O 内核缓冲,这是由内核维护的缓冲区,而标准 I/O 所维护的 stdio 缓冲是用户空间缓冲区
    • 当应用程序中通过标准 I/O 操作磁盘文件时,标准 I/O 函数会将用户写入或读取文件的数据缓存在 stdio 缓冲区,然后再一次性将 stdio 缓冲区中缓存的数据通过调用系统调用 I/O(文件 I/O)写入到文件 I/O 内核缓冲区或拷贝到应用程序的 buf 中
10.4.1 对 stdio 缓冲进行设置
1. setvbuf() 函数
  • 调用 setvbuf() 库函数可以对文件的 stdio 缓冲区进行设置,如:缓冲区的缓冲模式、缓冲区的大小、起始地址等

    #include <stdio.h>
    
    int setvbuf(FILE *stream, char *buf, int mode, size_t size);
    
  • stream

    • FILE 指针,用于指定对应的文件,每一个文件都可以设置它对应的 stdio 缓冲区
  • buf

    • 如果参数 buf 不为 NULL,那么 buf 指向 size 大小的内存区域将作为该文件的 stdio 缓冲区,因为 stdio 库会使用 buf 指向的缓冲区,所以应该以动态(分配在堆内存,如 malloc)或静态的方式在堆中为该缓冲区分配一块空间,而不是分配在栈上的函数内的自动变量(局部变量)
    • 如果 buf 等于 NULL,那么 stdio 库会自动分配一块空间作为该文件的 stdio 缓冲区(除非参数 mode 配置为非缓冲模式)
  • mode:用于指定缓冲区的缓冲类型

    • _IONBF:不对 I/O 进行缓冲(无缓冲)。意味着每个标准 I/O 函数将立即调用 write() 或者 read(),并且忽略 buf 和 size 参数,可以分别指定两个参数为 NULL 和 0。标准错误 stderr 默认属于这一种类型,从而保证错误信息能够立即输出
    • _IOLBF:采用行缓冲 I/O。这种情况下,当在输入或输出中遇到换行符 “\n” 时,标准 I/O 才会执行文件 I/O 操作
      • 对于输出流,在输出一个换行符前将数据缓存(除非缓冲区已经被填满),当输出换行符时,再将这一行数据通过文件 I/O write() 函数刷入到内核缓冲区中
      • 对于输入流,每次读取一行数据。对于终端设备默认采用的就是行缓冲模式,譬如标准输入和标准输出
    • _IOFBF:采用全缓冲 I/O。这种情况下,在填满 stdio 缓冲区后才进行文件 I/O 操作(read、write)
      • 对于输出流,当 fwrite 写入文件的数据填满缓冲区时,才调用 write() 将 stdio 缓冲区中数据刷入内核缓冲区
      • 对于输入流,每次读取 stdio 缓冲区大小个字节数据。默认普通磁盘上的常规文件常用这种缓冲模式
  • size:指定缓冲区的大小

  • 返回值:成功返回 0,失败将返回一个非 0 值,并设置 errno 指示错误原因

当 stdio 缓冲区中的数据被刷入到内核缓冲区或被读取之后,这些数据就不会存在于缓冲区中了,数据被刷入了内核缓冲区或被读走了

2. setbuf() 函数
  • setbuf() 函数构建于 setvbuf() 之上,执行类似的任务
    #include <stdio.h>
    
    void setbuf(FILE *stream, char *buf);
    
  • setbuf() 调用除了不返回函数结果(void)外,就相当于
    // 要么将 buf 设置为 NULL 以表示无缓冲
    // 要么指向由调用者分配的 BUFSIZ 个字节大小的缓冲区(BUFSIZ 定义于头文件 <stdio.h> 中,该值通常为 8192)
    setvbuf(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
    
3. setbuffer() 函数
  • setbuffer() 函数类似于 setbuf(),但允许调用者指定 buf 缓冲区的大小
    #include <stdio.h>
    
    void setbuffer(FILE *stream, char *buf, size_t size);
    
  • setbuffer() 调用除了不返回函数结果(void)外,就相当于
    setvbuf(stream, buf, buf ? _IOFBF : _IONBF, size);
    
10.4.2 标准输出 printf() 的行缓冲模式测试
  • 标准 printf() 输出测试
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(void) {
        printf("Hello World!\n");
        printf("Hello World!");
    
        for ( ; ; )
            sleep(1);
    }
    
    $ gcc io2.c -o io2
    $ ./io2
    Hello World!  # 只有第一个 printf() 打印的信息显示出来了,第二个并没有显示出来
    
    

这就是 stdio 缓冲的问题,标准输出默认采用的是行缓冲模式,printf() 输出的字符串写入到了标准输出的 stdio 缓冲区中,只有输出换行符时(不考虑缓冲区填满的情况)才会将这一行数据刷入到内核缓冲区,也就是写入标准输出文件(终端设备)

  • 第一个 printf 包含了换行符,所以已经刷入了内核缓冲区
  • 第二个 printf 没有包含换行符,所以输出的 “Hello World!” 还缓存在 stdio 缓冲区中,需要等待一个换行符才可输出到终端

  • 将标准输出配置为无缓冲模式
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(void) {
        /* 将标准输出设置为无缓冲模式 */
        if (setvbuf(stdout, NULL, _IONBF, 0)) {
            perror("setvbuf error");
            exit(0);
        }
    
        printf("Hello World!\n");
        printf("Hello World!");
    
        for ( ; ; )
            sleep(1);
    }
    
    $ gcc io3.c -o io3
    $ ./io3
    Hello World!
    Hello World!
    
    
10.4.3 刷新 stdio 缓冲区
  • 无论采取何种缓冲模式,在任何时候都可以使用库函数 fflush() 来强制刷新(将输出到 stdio 缓冲区中的数据写入到内核缓冲区)stdio 缓冲区,该函数会刷新指定文件的 stdio 输出缓冲区
    #include <stdio.h>
    
    // 参数 stream 指定需要进行强制刷新的文件,如果该参数设置为 NULL,则表示刷新所有的 stdio 缓冲区
    int fflush(FILE *stream);
    
  • 使用 fflush() 刷新 stdio 缓冲区
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(void) {
        printf("Hello World!\n");
        printf("Hello World!");
        fflush(stdout);  // 刷新标准输出 stdio 缓冲区
    
        for ( ; ; )
            sleep(1);
    }
    
    $ gcc io4.c -o io4
    $ ./io4
    Hello World!
    Hello World!
    

  • 使用库函数 fflush() 是一种强制刷新的手段,在一些其它的情况下,也会自动刷新 stdio 缓冲区
    • 关闭文件时系统自动刷新 stdio 缓冲区
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(void) {
        printf("Hello World!\n");
        printf("Hello World!");
        fclose(stdout);  // 关闭标准输出
    
        for ( ; ; )
            sleep(1);
    }
    

    上面的测试程序中,在最后都使用了一个 for 死循环,让程序处于休眠状态无法退出,为什么要这样做呢?原因在于程序退出时也会自动刷新 stdio 缓冲区,这样的话就会影响到测试结果,下面去掉 for 死循环,让程序结束

    • 程序退出时系统自动刷新 stdio 缓冲区
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(void) {
        printf("Hello World!\n");
        printf("Hello World!");
    }
    
    $ gcc io5.c -o io5
    $ ./io5
    Hello World!
    Hello World! $
    

如果使用 exit()、return 或像上述示例代码一样不显式调用相关函数或执行 return 语句来结束程序,这些情况下程序终止时会自动刷新 stdio 缓冲区,但是如果使用 _exit 或 _Exit() 终止程序则不会自动刷新 stdio 缓冲区

11. 文件描述符与 FILE 指针互转

  • 在同一个文件上执行 I/O 操作时,可以将文件 I/O(系统调用 I/O)与标准 I/O 混合使用,这个时候就需要将文件描述符和 FILE 指针对象之间进行转换,此时可以借助于库函数 fdopen()、fileno() 来完成
    • 库函数 fileno() 可以将标准 I/O 中使用的 FILE 指针转换为文件 I/O 中所使用的文件描述符
    • 而 fdopen() 则进行着相反的操作
    #include <stdio.h>
    
    int fileno(FILE *stream);
    FILE *fdopen(int fd, const char *mode);
    
  • 对于 fileno() 函数来说
    • 根据传入的 FILE 指针得到整数文件描述符,通过返回值得到文件描述符
    • 如果转换错误将返回 -1,并且会设置 errno 来指示错误原因
    • 得到文件描述符之后,便可以使用诸如 read()、write()、lseek()、fcntl()等文件 I/O 方式操作文件
  • fdopen() 函数与 fileno() 功能相反
    • 给定一个文件描述符,得到该文件对应的 FILE 指针
    • 之后便可以使用诸如 fread()、fwrite() 等标准 I/O 方式操作文件了

当混合使用文件 I/O 和标准 I/O 时,需要特别注意缓冲的问题

  • 文件 I/O 会直接将数据写入到内核缓冲区进行高速缓存
  • 标准 I/O 则会将数据写入到 stdio 缓冲区,之后再调用 write() 将 stdio 缓冲区中的数据写入到内核缓冲区
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void) {
    printf("print");  // 缺换行符 "\n"
    write(STDOUT_FILENO, "write\n", 6);

    exit(0);
}
$ gcc test.c -o test
$ ./test 
write   # 先输出了 "write" 字符串信息,接着再输出了 "print" 字符串信息
print $

文章来源:https://blog.csdn.net/qq_42994487/article/details/135023841
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。