参考引用
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 的内核缓冲区,但受限于物理内存的总量,操作越大的文件也要依赖于更大空间的内核缓冲区
- 1. 提高文件 I/O 的速度和效率(使得系统调用 read()、write()的操作更为快速)
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 $