一文带你深入浅出C语言文件操作

一文带你深入浅出C语言文件操作
目录

前言

🎐1. 为什么使用文件

🎐2. 什么是文件

🎐2.1 程序文件

🎐2.2 数据文件

🎐2.3 文件名

🎐3. 文件的打开和关闭

🎐3.1 文件指针

🎐3.2 文件的打开和关闭

🎐4. 文件的顺序读写

🎐4.1 小插曲——关于流的简单了解

🎐4.2 fputc函数

🎐4.3 fgetc函数

🎐4.4 fputs函数

🎐4.5 fgets函数

🎐4.6 fprintf函数

🎐4.7 fscanf函数

🎐4.8 fwrite函数

🎐4.9 fread函数

🎐4.10 对比一组函数

🎐4.10.1 sscanf函数

🎐4.10.2 sprintf函数

🎐4.10.3 综合示例

🎐5. 文件的随机读写

🎐5.1 fseek函数

🎐5.2 ftell函数

🎐5.3 rewind函数

🎐6. 文本文件和二进制文件

🎐7. 文件读取结束的判定

🎐7.1 被错误使用的feof

🎐7.2 如何判定文件读取结束

🎐7.3 正确的使用

🎐7.3.1 文本文件的例子

🎐7.3.2 二进制文件的例子

🎐8. 文件缓冲区

🎐敬请期待更好的作品吧~

前言

本文分享一波C语言的文件操作相关知识，由于笔者水平有限，难免存在纰漏，读者各取所需即可。

给你点赞，加油加油！

🎐1. 为什么使用文件

        之前学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。

        既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。这就涉及到了数据持久化的问题，一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

通过使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

🎐2. 什么是文件

        磁盘上的文件是文件。

        但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。

🎐2.1 程序文件

        包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。

🎐2.2 数据文件

        文件的内容不是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。

        本章讨论的是数据文件。

        在以前所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。

        其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。

🎐2.3 文件名

        一个文件要有一个唯一的文件标识，以便用户识别和引用。

        文件名包含3部分：文件路径+文件名主干+文件后缀

        例如： c:\code\test.txt

        那为什么要加上路径呢？因为不同的路径下可能存在同名文件。

        就好像一个村里可能会有好几个名字都叫张三的人，你不具体到哪一家哪一户的话怎么找到想找的那个张三呢？加上文件路径就好像标注了地址，这样就不会找错文件了。

        为了方便起见，文件标识常被称为文件名。

注意事项：

        文件名中有一些禁止使用的字符：

        文件名中不一定要包含后缀名。

        文件的后缀名决定了一个文件的默认打开方式。

        文件路径指的是从盘符到该文件所经历的路径中各符号名的集合。

🎐3. 文件的打开和关闭

对文件进行操作时，有三个步骤：

（1）打开文件

（2）读/写文件

（3）关闭文件

🎐3.1 文件指针

        缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。

        每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名FILE。

        每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。

        一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。

        下面我们可以创建一个FILE*的指针变量:
```
FILE* pf;//文件指针变量
```
        定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

🎐3.2 文件的打开和关闭

        文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。

        在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。

        ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件。

函数原型：
```
//打开文件
FILE * fopen ( const char * filename, const char * mode );
 
//关闭文件
int fclose ( FILE * stream );
```
        fopen函数的参数filename指的是目标文件标识，以字符串形式传入。值得注意的是，如果没有写上绝对路径的话会默认在相对路径下寻找该文件，一般都是加上绝对路径以准确找到目标文件。

        fopen函数的参数mode指的是文件打开后使用方式，具体如表格所示：

        注意：用'w'写入文件时是从第一个字符位开始写的，也就是说不管文件中原来有什么内容，直接覆盖掉，如果想要追加就使用'a'追加数据。

        fopen有可能会失败，打开失败的话返回NULL指针，所以要判断是否打开失败。

示例
```
#include 
int main ()
{
    FILE * pFile;
    //打开文件
    pFile = fopen ("myfile.txt","w");
    
    if (pFile!=NULL)
    {
        //文件操作
        fputs ("fopen example",pFile);
        //关闭文件
        fclose (pFile);
        pFile = NULL;
    }
    return 0;
}
```
🎐4. 文件的顺序读写

        之所以叫顺序读写，是因为下面介绍的函数读或写的时候都是从文件开头处按照从左到右、从上到下的顺序进行的。

🎐4.1 小插曲——关于流的简单了解

        数据的输入输出其实是需要通过流来实现的，各种设备之间的数据互通的方法不尽相同，通过封装流，来实现通过流传输数据，如同水流一般，至于到底如何实现的，这是C语言底层自己实现的，我们使用者不深究的话不用太了解，只需要关注流即可。前面讲到的文件指针其实就是流，我们通过它来实现数据的互通。

        有没有想过这样一个问题：为什么数据输出到文件或从文件中输入需要先打开文件（打开流），而从键盘输入和打印数据到屏幕看起来好像也没有打开流呀。

        任何一个C程序，只要运行起来就会默认打开3个流：

        FILE* stdin 标准输入流（键盘）

        FILE* stdout 标准输出流（屏幕）

        FILE* stderr 标准错误流（屏幕）

         所以使用printf或者scanf就不需要再打开流了，直接使用就行。

🎐4.2 fputc函数

        该函数将一个字符输出到文件。

函数原型
```
int fputc( int c, FILE *stream );
```
c就是要输出到文件的字符，stream就是文件名。

示例
```
int main()
{
	FILE* pf = fopen("D:\\test.txt", "r+");
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
 
	int i = 0;
 
	for (i = 'a'; i < 'g'; i++)
	{
		fputc(i, pf);
	}
 
	fclose(pf);
	pf = NULL;
 
	return 0;
}
```
🎐4.3 fgetc函数

该函数从文件中读取一个字符。

函数原型
```
int fgetc( FILE *stream );
```
        返回值就是从文件中读到的字符，从第一个字符开始读取。

        读取失败时返回EOF。

示例

        假设test.txt文件中已经放入了六个字符abcdef
```
int main()
{
    FILE* pf = fopen("D:\\test.txt", "r");
    if (NULL == pf)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    
    int i = 0;
    int ch = 0;
 
    while ((ch = fgetc(pf)) != EOF)
    {
        printf("%c ", ch);
    }
 
    fclose(pf);
    pf = NULL;
    return 0;
}
```
🎐4.4 fputs函数

该函数将一个字符串内容输出到文件。

函数原型
```
int fputs( const char *string, FILE *stream );
```
string是要输出的字符串的地址。

示例
```
int main()
{
    FILE* pf = fopen("D:\\test.txt", "w");
    if (NULL == pf)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
 
    char str[100] = "hello world";
 
    fputs(str, pf);
 
    fclose(pf);
    pf = NULL;
    return 0;
}
```
🎐4.5 fgets函数

该函数从文件中读取一定数量字符到字符串中。

函数原型
```
char *fgets( char *string, int n, FILE *stream );
```
        string是要被输入的字符串的地址，n是输入字符的个数。

        值得注意的是，在输入时会自动在末尾加上'\0'，并且这个'\0'是算在n的个数上的，也就是说实际输入的字符个数是n-1。

        如果读取成功，函数返回字符串地址，如果失败则返回NULL。

示例

        假设文件test.txt中已经放入了字符串hello world。
```
int main()
{
    FILE* pf = fopen("D:\\test.txt", "r");
    if (NULL == pf)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
 
    char str[100] = {0};
    fgets(str, 12, pf);    
    printf("%s\n", str);
 
    fclose(pf);
    pf = NULL;
    return 0;
}
```
🎐4.6 fprintf函数

该函数格式化输出字符串到文件。

函数原型
```
int fprintf( FILE *stream, const char *format [, argument ]...);
```
其实也就比printf在前面多了一个文件指针，差不了多少，按照某一种格式输出数据。

示例
```
int main()
{
    FILE* pf = fopen("D:\\test.txt", "w");
    if (NULL == pf)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
 
    char str[100] = "hello world";
    int a = 100;
    float b = 89.8;
    
    fprintf(pf, "%s a = %d, b = %f", str, a, b);
 
    fclose(pf);
    pf = NULL;
    return 0;
}
```
🎐4.7 fscanf函数

该函数从文件中格式化输入数据到字符串。

函数原型
```
int fscanf( FILE *stream, const char *format [, argument ]... );
```
其实也就比printf在前面多了一个文件指针，差不了多少，按照某一种格式读取数据。

示例

文件里放了这些数据：
```
int main()
{
	FILE* pf = fopen("D:\\test.txt", "r");
 
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
 
	char str[100] = { 0 };
	int a = 0;
	float b = 0;
 
	fscanf(pf, "%s %d %f", str, &a, &b);
	printf("%s  a = %d  b = %f", str, a, b);
 
	fclose(pf);
	pf = NULL;
	return 0;
}
```
🎐4.8 fwrite函数

该函数把数据以二进制形式输出到目标文件中。

函数原型
```
size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );
```
参数说明

buffer指针指向输出源，size表明数据大小，count表明数据个数，最后一个就是目标文件指针。

示例
```
struct s
{
	char str[100];
	int a;
	float b;
};
 
int main()
{
	FILE* pf = fopen("D:\\test.txt", "w");
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
 
	struct s tmp = { "helloworld", 10, 45.5 };
 
	fwrite(&tmp, sizeof(tmp), 2, pf);
 
	fclose(pf);
	pf = NULL;
	return 0;
}
```
🎐4.9 fread函数

该函数把二进制形式数据从文件输入到目标内存空间中。

函数原型
```
size_t fread( void *buffer, size_t size, size_t count, FILE *stream );
```
参数说明

buffer指针指向目标内存空间，size表明输入数据大小，count表明输入数据个数，最后一个是目标文件指针。

示例

文件里放的数据：
```
struct s
{
	char str[100];
	int a;
	float b;
};
 
int main()
{
	FILE* pf = fopen("D:\\test.txt", "w");
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
 
	struct s tmp = { 0 };
 
	fread(&tmp, sizeof(tmp), 1, pf);
	printf("%s\n%d\n%f ", tmp.str, tmp.a, tmp.b);
 
	fclose(pf);
	pf = NULL;
	return 0;
}
```
🎐4.10 对比一组函数

        scanf/fscanf/sscanf

        printf/fprintf/sprintf

        scanf是针对标准输入的格式化输入语句

        printf是针对标准输出的格式化输出语句

        fscanf是针对所有输入流的格式化输入语句

        fprintf是针对所有输出流的格式化输出语句

        那最后面的sscanf和sprintf见过没？好像以前没见过欸，到底是干什么用的呢？

🎐4.10.1 sscanf函数

函数原型
```
int sscanf( const char *buffer, const char *format [, argument ] ... );
```
从一个字符串中格式化地取出的数据放到别处。

🎐4.10.2 sprintf函数

函数原型
```
int sprintf( char *buffer, const char *format [, argument] ... );
```
从别处把数据格式化后写到一个字符串中。

参数说明

buffer指针指向要写入的字符串，后面的就是格式字符串了（不讲可变参数列表）。

🎐4.10.3 综合示例
```
struct s
{
	char str[100];
	int a;
	float b;
};
 
int main()
{
	FILE* pf = fopen("D:\\test.txt", "w");
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
 
	struct s tmp = { "helloworld", 10, 45.5 };
	struct s rad;
	char str[100] = { 0 };
 
	//把结构体tmp中的数据按格式转化成字符串放入str中
	sprintf(str, "%s %d %f", tmp.str, &(tmp.a), &(tmp.b));
 
	//把str字符串按格式取出数据放入结构体rad中
	sscanf(str, "%s %d %f", rad.str, &(rad.a), &(rad.b));
 
	//分别打印str字符串和rad结构体
	printf("%s\n", str);
	printf("%s %d %f\n", rad.str, rad.a, rad.b);
 
	fclose(pf);
	pf = NULL;
	return 0;
}
```
        注意：sscanf和sprintf不针对流。

🎐5. 文件的随机读写

        前面讲的是顺序读写，也就是每次读写都是按照从文件开始处操作，而这里要讲的随机读写就是说可以使用下面几个函数实现在文件中任意想要的位置处进行读写操作。

🎐5.1 fseek函数

        根据文件指针的位置和偏移量来定位文件指针。

函数原型
```
int fseek ( FILE * stream, long int offset, int origin );
```
传入一个文件指针，从origin给定的位置开始计算偏移，偏移量为offset，把传入的指针定位在计算得到的偏移位置。

关于origin不同取值对应不同位置：

例子
```
#include
int main()
{
	FILE* pFile;
	pFile = fopen("D:\\test.txt", "w");
	if (pFile == NULL)
		perror("Error opening file");
	else 
	{
		fputs("This is an apple.", pFile);
		fseek(pFile, 9, SEEK_SET);
		fputs(" sam", pFile);
		fclose(pFile);
	}
 
	return 0;
}
```
这里origin设置的是在文件的开始处，向后偏移9个字符，然后从这里开始输出第二个字符串到文件中。

🎐5.2 ftell函数

返回文件指针相对于起始位置的偏移量。

函数原型
```
long int ftell ( FILE * stream );
```
例子
```
#include
int main()
{
	FILE* pFile;
	long size;
	pFile = fopen("D:\\test.txt", "r");
	if (pFile == NULL) 
		perror("Error opening file");
	else
	{
		fseek(pFile, 0, SEEK_END); //先让文件指针指向文件末尾
		size = ftell(pFile);//这时候计算相对于文件开始处的偏移量即可算出文件大小
		fclose(pFile);
		printf("Size of test.txt: %ld bytes.\n", size);
	}
	return 0;
}
```
🎐5.3 rewind函数

让文件指针的位置回到文件的起始位置。

函数原型
```
void rewind ( FILE * stream );
```
例子
```
#include
int main()
{
	int n;
	FILE* pFile;
	char buffer[27];
 
	pFile = fopen("D:\\test.txt", "w+");
	for (n = 'A'; n <= 'Z'; n++)
		fputc(n, pFile);
	rewind(pFile);
	fread(buffer, 1, 26, pFile);
	fclose(pFile);
 
	buffer[26] = '\0';
	puts(buffer);
 
	return 0;
}
```
🎐6. 文本文件和二进制文件

        根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

        数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。

        如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

        一个数据在内存中是怎么存储的呢？

        字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

        如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节。

测试代码
```
#include 
int main()
{
	int a = 10000;
	FILE* pf = fopen("D:\\test.txt", "wb");
	fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
	fclose(pf);
	pf = NULL;
	return 0;
}
```
        我们如果想要查看二进制文件，可以先把该文件添加到VS当前项目：

         再使用二进制编辑器打开即可。

🎐7. 文件读取结束的判定

🎐7.1 被错误使用的feof

        牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件读取是否结束。

        当文件读取结束的时候，用ferror()判断是否读取失败结束，feof()判断是否遇到文件尾结束，它们两个常常放在一起判断文件读取结束的原因。

🎐7.2 如何判定文件读取结束

1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）

例如：

        fgetc 判断是否为 EOF 。

        fgets 判断返回值是否为 NULL 。

2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。

例如：

        fread判断返回值是否小于实际要读的个数。

🎐7.3 正确的使用

🎐7.3.1 文本文件的例子
```
#include 
#include 
 
int main()
{
	int c; // 注意：int，非char，要求处理EOF
	FILE* fp = fopen("test.txt", "r");
	if (!fp) 
	{
		perror("File opening failed");
		return EXIT_FAILURE;
	}
 
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环
	{
		putchar(c);
	}
 
	//判断是什么原因结束的
	if (ferror(fp))
		puts("I/O error when reading");
	else if (feof(fp))
		puts("End of file reached successfully");
 
	fclose(fp);
	fp = NULL;
	return 0;
}
```
🎐7.3.2 二进制文件的例子
```
#include 
#define SIZE 5
int main(void)
{
	double a[SIZE] = { 1.0,2.0,3.0,4.0,5.0 };
 
	FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式
	fwrite(a, sizeof(*a), SIZE, fp); // 写 double 的数组
 
	fclose(fp);
 
	double b[SIZE];
 
	fp = fopen("test.bin", "rb");
	size_t ret_code = fread(b, sizeof * b, SIZE, fp); //读 double 的数组
	if (ret_code == SIZE)
    {
		puts("Array read successfully, contents: ");
		for (int n = 0; n < SIZE; ++n) 
            printf("%f ", b[n]);
		putchar('\n');
	}
	else 
    { 
		if (feof(fp))
			printf("Error reading test.bin: unexpected end of file\n");
		else if (ferror(fp))
        {
			perror("Error reading test.bin");
		}
	}
 
	fclose(fp);
    fp = NULL;
    return 0;
}
```
🎐8. 文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，刷新缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区，刷新缓冲区后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。

简单地证明一下文件缓冲区的存在：
```
#include 
#include 
//VS2013 WIN10环境测试
int main()
{
	FILE* pf = fopen("test.txt", "w");
	fputs("abcdef", pf);//先将代码放在输出缓冲区
	printf("睡眠10秒\n");
	Sleep(10000);
	printf("已经写数据了，此时打开test.txt文件，发现文件没有内容\n");
	printf("刷新缓冲区\n");
	fflush(pf);//刷新缓冲区，此时才将输出缓冲区的数据写到文件（磁盘）
	//注：fflush 在高版本的VS上不能使用了
	printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
	Sleep(10000);
	fclose(pf);//fclose在关闭文件的时候，也会刷新缓冲区
	pf = NULL;
	return 0;
}
```
因为有缓冲区的存在，C语言在操作文件的时候，需要刷新缓冲区或者文件操作结束时要关闭文件。

如果不做，可能导致读写文件时出现问题。

🎐敬请期待更好的作品吧~

感谢观看，你的支持就是对我最大的鼓励，阁下何不成人之美，点赞收藏关注走一波~
相关阅读:
redis做缓存,mysql的数据怎么与redis进行同步(双写一致性)
单词拼写引起的错误_username_uername
Eureka Server 实现在线扩容
 RabbitMQ快速入门笔记
 unable to boot the simulator. domain nsposixerrordomain code 4
谣言检测(RDCL)——《Towards Robust False Information Detection on Social Networks with Contrastive Learning》
企业微信开发文档
 Java之LinkedList()
CSP初赛知识精讲--排列组合
 微信小程序毕业设计题目学生公寓生活管理系统+后台管理系统|前后分离VUE.js
原文地址：https://blog.csdn.net/weixin_61561736/article/details/125872395

前言

🎐1. 为什么使用文件

🎐2. 什么是文件

🎐2.1 程序文件

🎐2.2 数据文件

🎐2.3 文件名

🎐3. 文件的打开和关闭

🎐3.1 文件指针

🎐3.2 文件的打开和关闭

🎐4. 文件的顺序读写

🎐4.1 小插曲——关于流的简单了解

🎐4.2 fputc函数

🎐4.3 fgetc函数

🎐4.4 fputs函数

🎐4.5 fgets函数

🎐4.6 fprintf函数

🎐4.7 fscanf函数

🎐4.8 fwrite函数

🎐4.9 fread函数

🎐4.10 对比一组函数

🎐4.10.1 sscanf函数

🎐4.10.2 sprintf函数

🎐4.10.3 综合示例

🎐5. 文件的随机读写

🎐5.1 fseek函数

🎐5.2 ftell函数

🎐5.3 rewind函数

🎐6. 文本文件和二进制文件

🎐7. 文件读取结束的判定

🎐7.1 被错误使用的feof

🎐7.2 如何判定文件读取结束

🎐7.3 正确的使用

🎐7.3.1 文本文件的例子

🎐7.3.2 二进制文件的例子

🎐8. 文件缓冲区

🎐敬请期待更好的作品吧~