参考引用

• UNIX 环境高级编程 (第3版)
• 嵌入式Linux C应用编程-正点原子

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 $