C语言文件IO

C语言文件接口汇总

C语言中的文件操作函数如下：

文件操作函数	功能
fopen	打开文件
fclose	关闭文件
fputc	写入一个字符
fgetc	读取一个字符
fputs	写入一个字符串
fgets	读取一个字符串
fprintf	格式化写入数据
fscanf	格式化读取数据
fwrite	向二进制文件写入数据
fread	从二进制文件读取数据
fseek	设置文件指针的位置
ftell	计算当前文件指针相对于起始位置的偏移量
rewind	设置文件指针到文件的起始位置
ferror	判断文件操作过程中是否发生错误
feof	判断文件指针是否读取到文件末尾

下面只会选择性对C语言的部分文件操作函数进行使用，若想详细了解其余文件操作函数的使用方法，请跳转到博主的其它博客：

• 一、文件的打开与关闭函数（fopen、fclose）
• 二、文件的顺序读写（fgetc、fputc、fgets、fputs、fscanf、fprintf、fread、fwrite）
• 三、文件的随机读写（fseek、ftell）
• 四、文件的结束判定（ferror、feof）

对文件进行写入操作示例：

#include <stdio.h>
int main()

	FILE* fp = fopen("log.txt", "w");
	if (fp == NULL)
		perror("fopen");
		return 1;
	
	int count = 5;
	while (count)
		fputs("hello world\\n", fp);
		count--;
	
	fclose(fp);
	return 0;

运行程序后，在当前路径下就会生成对应文件，文件当中就是我们写入的内容。

对文件进行读取操作示例：

#include <stdio.h>
int main()

	FILE* fp = fopen("log.txt", "r");
	if (fp == NULL)
		perror("fopen");
		return 1;
	
	char buffer[64];
	for (int i = 0; i < 5; i++)
		fgets(buffer, sizeof(buffer), fp);
		printf("%s", buffer);
	
	fclose(fp);
	return 0;

运行程序后，就会将我们刚才写入文件的内容读取出来，并打印在显示器上。

什么是当前路径？

我们知道，当fopen以写入的方式打开一个文件时，若该文件不存在，则会自动在当前路径创建该文件，那么这里所说的当前路径指的是什么呢？

例如，我们在BasicIO目录下运行可执行程序myproc，那么该可执行程序创建的log.txt文件会出现在BasicIO目录下。

那是否意味着这里所说的“当前路径”是指“当前可执行程序所处的路径”呢？
这时我们可以将刚才可执行程序生成的log.txt文件先删除，然后再做一个测试：回退到上级目录，在上级目录下运行该可执行程序。

这时我们可以发现，该可执行程序运行后并没有在BasicIO目录下创建log.txt文件，而是在我们当前所处的路径下创建了log.txt文件。

当该可执行程序运行起来变成进程后，我们可以获取该进程的PID，然后根据该PID在根目录下的proc目录下查看该进程的信息。

在这里我们可以看到两个软链接文件cwd和exe，cwd就是进程运行时我们所处的路径，而exe就是该可执行程序的所处路径。

总结： 实际上，我们这里所说的当前路径不是指可执行程序所处的路径，而是指该可执行程序运行成为进程时我们所处的路径。

默认打开的三个流

都说Linux下一切皆文件，也就是说Linux下的任何东西都可以看作是文件，那么显示器和键盘当然也可以看作是文件。我们能看到显示器上的数据，是因为我们向“显示器文件”写入了数据，电脑能获取到我们敲击键盘时对应的字符，是因为电脑从“键盘文件”读取了数据。

为什么我们向“显示器文件”写入数据以及从“键盘文件”读取数据前，不需要进行打开“显示器文件”和“键盘文件”的相应操作？

需要注意的是，打开文件一定是进程运行的时候打开的，而任何进程在运行的时候都会默认打开三个输入输出流，即标准输入流、标准输出流以及标准错误流，对应到C语言当中就是stdin、stdout以及stderr。
其中，标准输入流对应的设备就是键盘，标准输出流和标准错误流对应的设备都是显示器。

查看man手册我们就可以发现，stdin、stdout以及stderr这三个家伙实际上都是FILE*类型的。

extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;

当我们的C程序被运行起来时，操作系统就会默认使用C语言的相关接口将这三个输入输出流打开，之后我们才能调用类似于scanf和printf之类的函数向键盘和显示器进行相应的输入输出操作。

也就是说，stdin、stdout以及stderr与我们打开某一文件时获取到的文件指针是同一个概念，试想我们使用fputs函数时，将其第二个参数设置为stdout，此时fputs函数会不会之间将数据显示到显示器上呢？

#include <stdio.h>
int main()

	fputs("hello stdin\\n", stdout);
	fputs("hello stdout\\n", stdout);
	fputs("hello stderr\\n", stdout);
	return 0;

答案是肯定的，此时我们相当于使用fputs函数向“显示器文件”写入数据，也就是显示到显示器上。

注意： 不止是C语言当中有标准输入流、标准输出流和标准错误流，C++当中也有对应的cin、cout和cerr，其他所有语言当中都有类似的概念。实际上这种特性并不是某种语言所特有的，而是由操作系统所支持的。

系统文件I/O

操作文件除了C语言接口、C++接口或是其他语言的接口外，操作系统也有一套系统接口来进行文件的访问。
相比于C库函数或其他语言的库函数而言，系统调用接口更贴近底层，实际上这些语言的库函数都是对系统接口进行了封装。

我们在Linux平台下运行C代码时，C库函数就是对Linux系统调用接口进行的封装，在Windows平台下运行C代码时，C库函数就是对Windows系统调用接口进行的封装，这样做使得语言有了跨平台性，也方便进行二次开发。

open

系统接口中使用open函数打开文件，open函数的函数原型如下：

int open(const char *pathname, int flags, mode_t mode);

open的第一个参数

open函数的第一个参数是pathname，表示要打开或创建的目标文件。

• 若pathname以路径的方式给出，则当需要创建该文件时，就在pathname路径下进行创建。
• 若pathname以文件名的方式给出，则当需要创建该文件时，默认在当前路径下进行创建。（注意当前路径的含义）

open的第二个参数

open函数的第二个参数是flags，表示打开文件的方式。

其中常用选项有如下几个：

参数选项	含义
O_RDONLY	以只读的方式打开文件
O_WRNOLY	以只写的方式打开文件
O_APPEND	以追加的方式打开文件
O_RDWR	以读写的方式打开文件
O_CREAT	当目标文件不存在时，创建文件

打开文件时，可以传入多个参数选项，当有多个选项传入时，将这些选项用“或”运算符隔开。
例如，若想以只写的方式打开文件，但当目标文件不存在时自动创建文件，则第二个参数设置如下：

O_WRONLY | O_CREAT

扩展：

系统接口open的第二个参数flags是整型，有32比特位，若将一个比特位作为一个标志位，则理论上flags可以传递32种不同的标志位。

实际上传入flags的每一个选项在系统当中都是以宏的方式进行定义的：

例如，O_RDONLY、O_WRONLY、O_RDWR和O_CREAT在系统当中的宏定义如下：

#define O_RDONLY         00
#define O_WRONLY         01
#define O_RDWR           02
#define O_CREAT        0100

这些宏定义选项的共同点就是，它们的二进制序列当中有且只有一个比特位是1(O_RDONLY选项的二进制序列为全0，表示O_RDONLY选项为默认选项)，且为1的比特位是各不相同的，这样一来，在open函数内部就可以通过使用“与”运算来判断是否设置了某一选项。

int open(arg1, arg2, arg3)
	if (arg2&O_RDONLY)
		//设置了O_RDONLY选项
	
	if (arg2&O_WRONLY)
		//设置了O_WRONLY选项
	
	if (arg2&O_RDWR)
		//设置了O_RDWR选项
	
	if (arg2&O_CREAT)
		//设置了O_CREAT选项
	
	//...

open的第三个参数

open函数的第三个参数是mode，表示创建文件的默认权限。

例如，将mode设置为0666，则文件创建出来的权限如下：

但实际上创建出来文件的权限值还会受到umask（文件默认掩码）的影响，实际创建出来文件的权限为：mode&(~umask)。umask的默认值一般为0002，当我们设置mode值为0666时实际创建出来文件的权限为0664。

若想创建出来文件的权限值不受umask的影响，则需要在创建文件前使用umask函数将文件默认掩码设置为0。

umask(0); //将文件默认掩码设置为0

注意： 当不需要创建文件时，open的第三个参数可以不必设置

open的返回值

open函数的返回值是新打开文件的文件描述符。

我们可以尝试一次打开多个文件，然后分别打印它们的文件描述符。

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main()

	umask(0);
	int fd1 = open("log1.txt", O_RDONLY | O_CREAT, 0666);
	int fd2 = open("log2.txt", O_RDONLY | O_CREAT, 0666);
	int fd3 = open("log3.txt", O_RDONLY | O_CREAT, 0666);
	int fd4 = open("log4.txt", O_RDONLY | O_CREAT, 0666);
	int fd5 = open("log5.txt", O_RDONLY | O_CREAT, 0666);
	printf("fd1:%d\\n", fd1);
	printf("fd2:%d\\n", fd2);
	printf("fd3:%d\\n", fd3);
	printf("fd4:%d\\n", fd4);
	printf("fd5:%d\\n", fd5);
	return 0;

运行程序后可以看到，打开文件的文件描述符是从3开始连续且递增的。

我们再尝试打开一个根本不存在的文件，也就是open函数打开文件失败。

#include <stdio.h>                                                                                       
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()

    int fd = open("test.txt", O_RDONLY);
    printf("%d\\n", fd);
    return 0;

运行程序后可以看到，打开文件失败时获取到的文件描述符是-1。

实际上这里所谓的文件描述符本质上是一个指针数组的下标，指针数组当中的每一个指针都指向一个被打开文件的文件信息，通过对应文件的文件描述符就可以找到对应的文件信息。
当使用open函数打开文件成功时数组当中的指针个数增加，然后将该指针在数组当中的下标进行返回，而当文件打开失败时直接返回-1，因此，成功打开多个文件时所获得的文件描述符就是连续且递增的。
而Linux进程默认情况下会有3个缺省打开的文件描述符，分别就是标准输入0、标准输出1、标准错误2，这就是为什么成功打开文件时所得到的文件描述符是从3开始进程分配的。

close

系统接口中使用close函数关闭文件，close函数的函数原型如下：

int close(int fd);

使用close函数时传入需要关闭文件的文件描述符即可，若关闭文件成功则返回0，若关闭文件失败则返回-1。

write

系统接口中使用write函数向文件写入信息，write函数的函数原型如下：

ssize_t write(int fd, const void *buf, size_t count);

我们可以使用write函数，将buf位置开始向后count字节的数据写入文件描述符为fd的文件当中。

• 如果数据写入成功，实际写入数据的字节个数被返回。
• 如果数据写入失败，-1被返回。

对文件进行写入操作示例：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()

	int fd = open("log.txt", O_WRONLY | O_CREAT, 0666);
	if (fd < 0)
		perror("open");
		return 1;
	
	const char* msg = "hello syscall\\n";
	for (int i = 0; i < 5; i++)
		write(fd, msg, strlen(msg));
	
	close(fd);
	return 0;

运行程序后，在当前路径下就会生成对应文件，文件当中就是我们写入的内容。

read

系统接口中使用read函数从文件读取信息，read函数的函数原型如下：

ssize_t read(int fd, void *buf, size_t count);

我们可以使用read函数，从文件描述符为fd的文件读取count字节的数据到buf位置当中。

• 如果数据读取成功，实际读取数据的字节个数被返回。
• 如果数据读取失败，-1被返回。

对文件进行读取操作示例：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()

	int fd = open("log.txt", O_RDONLY);
    if (fd < 0)
		perror("open");
		return 1;
	
	char ch;
	while (1)
		ssize_t s = read(fd, &ch, 1);
		if (s <= 0)
			break;
		
		write(1, &ch, 1); //向文件描述符为1的文件写入数据，即向显示器写入数据
	
	close(fd);
	return 0;

运行程序后，就会将我们刚才写入文件的内容读取出来，并打印在显示器上。

文件描述符fd

文件是由进程运行时打开的，一个进程可以打开多个文件，而系统当中又存在大量进程，也就是说，在系统中任何时刻都可能存在大量已经打开的文件。
因此，操作系统务必要对这些已经打开的文件进行管理，操作系统会为每个已经打开的文件创建各自的struct file结构体，然后将这些结构体以双链表的形式连接起来，之后操作系统对文件的管理也就变成了对这张双链表的增删查改等操作。
而为了区分已经打开的文件哪些属于特定的某一个进程，我们就还需要建立进程和文件之间的对应关系。

进程和文件之间的对应关系是如何建立的？

我们知道，当一个程序运行起来时，操作系统会将该程序的代码和数据加载到内存，然后为其创建对应的task_struct、mm_struct、页表等相关的数据结构，并通过页表建立虚拟内存和物理内存之间的映射关系。

而task_struct当中有一个指针，该指针指向一个名为files_struct的结构体，在该结构体当中就有一个名为fd_array的指针数组，该数组的下标就是我们所谓的文件描述符。
当进程打开log.txt文件时，我们需要先将该文件从磁盘当中加载到内存，形成对应的struct file，将该struct file连入文件双链表，并将该结构体的首地址填入到fd_array数组当中下标为3的位置，使得fd_array数组中下标为3的指针指向该struct file，最后返回该文件的文件描述符给调用进程即可。

因此，我们只要有某一文件的文件描述符，就可以找到与该文件相关的文件信息，进而对文件进行一系列输入输出操作。

注意： 向文件写入数据时，是先将数据写入到对应文件的缓冲区当中，然后定期将缓冲区数据刷新到磁盘当中。

什么叫做进程创建的时候会默认打开0、1、2？

0就是标准输入流，对应键盘；1就是标准输出流，对应显示器；2就是标准错误流，也是对应显示器。
而键盘和显示器都属于硬件，属于硬件就意味着操作系统能够识别到，当某一进程创建时，操作系统就会根据键盘、显示器、显示器形成各自的struct file，将这3个struct file连入文件双链表当中，并将这3个struct file的地址分别填入fd_array数组下标为0、1、2的位置，至此就默认打开了标准输入流、标准输出流和标准错误流。

磁盘文件 VS 内存文件？

当文件存储在磁盘当中时，我们将其称之为磁盘文件，而当磁盘文件被加载到内存当中后，我们将加载到内存当中的文件称之为内存文件。磁盘文件和内存文件之间的关系就像程序和进程的关系一样，当程序运行起来后便成了进程，而当磁盘文件加载到内存后便成了内存文件。
磁盘文件由两部分构成，分别是文件内容和文件属性。文件内容就是文件当中存储的数据，文件属性就是文件的一些基本信息，例如文件名、文件大小以及文件创建时间等信息都是文件属性，文件属性又被称为元信息。
文件加载到内存时，一般先加载文件的属性信息，当需要对文件内容进行读取、输入或输出等操作时，再延后式的加载文件数据。

文件描述符的分配规则

尝试连续打开五个文件，看看这五个打开后获取到的文件描述符。

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main()

	umask(0);
	int fd1 = open("log1.txt", O_RDONLY | O_CREAT, 0666);
	int fd2 = open("log2.txt", O_RDONLY | O_CREAT, 0666);
	int fd3 = open("log3.txt", O_RDONLY | O_CREAT, 0666);
	int fd4 = open("log4.txt", O_RDONLY | O_CREAT, 0666);
	int fd5 = open("log5.txt", O_RDONLY | O_CREAT, 0666);
	printf("fd1:%d\\n", fd1);
	printf("fd2:%d\\n", fd2);
	printf("fd3:%d\\n", fd3);
	printf("fd4:%d\\n", fd4);
	printf("fd5:%d\\n", fd5);
	return 0;

可以看到这五个文件获取到的文件描述符都是从3开始连续递增的，这很好理解，因为文件描述符本质就是数组的下标，而当进程创建时就默认打开了标准输入流、标准输出流和标准错误流，也就是说数组当中下标为0、1、2的位置已经被占用了，所以只能从3开始进行分配。

若我们在打开这五个文件前，先关闭文件描述符为0的文件，此后文件描述符的分配又会是怎样的呢？

close(0);

可以看到，第一个打开的文件获取到的文件描述符变成了0，而之后打开文件获取到的文件描述符还是从3开始依次递增的。

我们再试试在打开这五个文件前，将文件描述符为0和2的文件都关闭（不要将文件描述符为1的文件关闭，因为这意味着关闭了显示器文件，此时运行程序将不会有任何输出）。

close(0);
close(2);

可以看到前两个打开的文件获取到的文件描述符是0和2，之后打开文件获取到的文件描述符才是从3开始依次递增的。

结论： 文件描述符是从最小但是没有被使用的fd_array数组下标开始进行分配的。

重定向

重定向的原理

在明确了文件描述符的概念及其分配规则后，现在我们已经具备理解重定向原理的能力了。看完下面三个例子后，你会发现重定向的本质就是修改文件描述符下标对应的struct file*的内容。

输出重定向原理

输出重定向就是，将我们本应该输出到一个文件的数据重定向输出到另一个文件中。

例如，如果我们想让本应该输出到“显示器文件”的数据输出到log.txt文件当中，那么我们可以在打开log.txt文件之前将文件描述符为1的文件关闭，也就是将“显示器文件”关闭，这样一来，当我们后续打开log.txt文件时所分配到的文件描述符就是1。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()

	close(1);
	int fd = open("log.txt", O_WRONLY | O_CREAT, 0666);
	if (fd < 0)
		perror("open");
		return 1;
	
	printf("hello world\\n");
	printf("hello world\\n");
	printf("hello world\\n");
	printf("hello world\\n");
	printf("hello world\\n");
	fflush(stdout);
	
	close(fd);
	return 0;

运行结果后，我们发现显示器上并没有输出数据，对应数据输出到了log.txt文件当中。

说明一下：

1. printf函数是默认向stdout输出数据的，而stdout指向的是一个struct FILE类型的结构体，该结构体当中有一个存储文件描述符的变量，而stdout指向的FILE结构体中存储的文件描述符就是1，因此printf实际上就是向文件描述符为1的文件输出数据。
2. C语言的数据并不是立马写到了内存操作系统里面，而是写到了C语言的缓冲区当中，所以使用printf打印完后需要使用fflush将C语言缓冲区当中的数据刷新到文件中。

追加重定向原理

追加重定向和输出重定向的唯一区别就是，输出重定向是覆盖式输出数据，而追加重定向是追加式输出数据。
查看详情

linux入门基础io(代码片段)

基础IO✔回顾C文件的接口✔系统文件I/O✔文件描述符文件描述符的分配规则重定向✔FILE缓冲区fclose和close✔dup2系统调用✔理解文件系统inode硬链接软链接文件的三个时间✔回顾C文件的接口在学习C语言时我们了解了一些C语言的对... 查看详情

linux下的基础io(代码片段)

目录一.C语言文件IO操作(库函数)1.打开文件fopen 2.写入二进制文件fwrite和读取二进制文件fread3.关闭文件fclose 二.系统文件IO(系统调用接口)1.打开文件open系统调用2.读文件read和写文件write3.关闭文件close  三.文件描述符1.系统管理... 查看详情

linux:基础io(代码片段)

...述符三，静态库和动态库总结前言本文将为大家介绍基础IO的相关知识，让我一起来学习吧。一，复习C语言当中学习的文件接口操作FILE*fopen(constchar*path,constchar*mode); path:待要打开的文件 mode:以何种方式打开 r:可读方... 查看详情

linux:基础io(代码片段)

...述符三，静态库和动态库总结前言本文将为大家介绍基础IO的相关知识，让我一起来学习吧。一，复习C语言当中学习的文件接口操作FILE*fopen(constchar*path,constchar*mode); path:待要打开的文件 mode:以何种方式打开 r:可读方... 查看详情

linux基础io(代码片段)

文章目录一.C文件IO相关操作二.系统文件IOopen函数返回值重定向使用dup2系统调用给简易shell中增加重定向功能理解文件系统理解软硬链接三.动态库和静态库制作动静态库一.C文件IO相关操作只有文件名但不带路径的话，默认在... 查看详情

linux基础io(代码片段)

文章目录一.C文件IO相关操作二.系统文件IOopen函数返回值重定向使用dup2系统调用给简易shell中增加重定向功能理解文件系统理解软硬链接三.动态库和静态库制作动静态库一.C文件IO相关操作只有文件名但不带路径的话，默认在... 查看详情

linux基础io(代码片段)

目录系统文件IOopenwritereadclose文件描述符fdFILE重定向使用dup2系统调用文件系统磁盘磁盘和内存交互磁盘的分区与格式化Ext2文件系统的存储方案inode软硬链接软连接硬链接文件的三个时间系统文件IOopenopen接口的作用是打开文件。... 查看详情

linux基础io(代码片段)

目录系统文件IOopenwritereadclose文件描述符fdFILE重定向使用dup2系统调用文件系统磁盘磁盘和内存交互磁盘的分区与格式化Ext2文件系统的存储方案inode软硬链接软连接硬链接文件的三个时间系统文件IOopenopen接口的作用是打开文件。... 查看详情

linux基础io(代码片段)

文章目录C语言文件IOC语言文件接口汇总什么是当前路径？默认打开的三个流系统文件I/Oopenopen的第一个参数open的第二个参数open的第三个参数open的返回值closewriteread文件描述符fd文件描述符的分配规则重定向重定向的原理dup2... 查看详情

13linux下的基础io(代码片段)

不同操作系统所暴露出的接口是不同的，因此Linux下的一些系统调用接口是无法移植到Windows下的。文章目录一、C语言中的文件接口二、系统文件I/O2.1.系统调用接口open2.2.文件描述符fd（filedescriptor）2.3.补充内容--函数... 查看详情

5.linux基础io(代码片段)

目录open系统调用和库函数重定向文件管理、理解文件系统静态库动态库怎么打包文件 =内容+属性FILE*,c语言，软件如何理解硬件和软件的关系stdin,标准输入，键盘stdout，标准输出，显示器stderr，标准错误... 查看详情

linux练习生基础io（详细）(代码片段)

本节我们讲解基础IO的部分，将围绕以下内容进行梳理讲解：复习C文件IO相关操作认识文件相关系统调用接口认识文件描述符,理解重定向对比fd和FILE，理解系统调用和库函数的关系理解文件系统中inode的概念认识软硬... 查看详情

《linux从0到99》九基础io(代码片段)

基础IO1.回顾c语言文件操作接口2.系统调用文件操作系统01open函数02read函数03write函数04lseek函数05close函数3.文件描述符0&1&2文件描述符的分配规则（最小未分配原则）4.文件描述符与文件流指针的区别01文件流指针的本... 查看详情

万字详解linux系列基础io(代码片段)

文章目录前言（1）当前目录（2）stdin、stdout、stderr一、open（1）标志位（2）O_WRONLY（3）O_CREAT二、close，read，write三、文件描述符1.概念2.原理3.分配规则四、重定向1.输出 查看详情

万字详解linux系列基础io(代码片段)

文章目录前言（1）当前目录（2）stdin、stdout、stderr一、open（1）标志位（2）O_WRONLY（3）O_CREAT二、close，read，write三、文件描述符1.概念2.原理3.分配规则四、重定向1.输出 查看详情

linux文件系统与基础io(代码片段)

文件的宏观理解1⃣️文件在哪里呢？“狭义”上在磁盘，“广义”上一切皆文件。主要研究“狭义”，磁盘为外设，那么对文件的所有操作，本质都是对外设的输入输出，简称IO2⃣️文件是什么？空文... 查看详情

linux篇第九篇——基础io（系统文件io+文件描述符+重定向+文件系统+软硬链接）(代码片段)

⭐️这篇博客就要开始聊一聊Linux中基础IO相关知识，IO相信大家都不陌生，我们在C/C++中对文件进行读写的操作，也就是文件IO，这篇博客我也会带大家回顾一下。这篇博客还会介绍系统中的文件IO调用的接... 查看详情