【C语言】文件操作超详解（全）

一、使用文件的概念和意义

1.1、什么是文件

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

1.2、为什么使用文件

如果没有文件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失 了，等再次运行程序，是看不到上次程序的数据的，如果要将数据进行持久化的保存，我们可以使用文件。

1.3、程序文件和数据文件

1. 程序文件：包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows 环境后缀为.exe）。
2. 数据文件：文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。

本章讨论的是数据文件。 在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。 其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。

如果看不懂的话，我给大家画幅图来理清楚这个关系：

1.4、文件名

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

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

例如：c:\code\test.txt

二、二进制文件和文本文件

分类原因： 根据数据的组织形式，数据文件被分为文本文件和二进制文件。

1. 二进制文件：数据在内存中以二进制的形式存储，如果不加转换的输出到外存的文件中，就是二进制文件。
2. 文本文件：如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

那么一个数据在文件中是怎么存储的呢？

• 字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
• 如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节。

给大家画幅图来直观的感受一下：

解释：

ASCII形式存储：1的ASCALL值为49，0的ASCALL值为48，所以0和1在存储的时候就按照二进制的形式进行存储，并且存储5个字节的空间大小。

二进制形式存储：10000使用二进制的形式进行存储，由于不够32位，前面补0即可。

代码演示：

#include <stdio.h>

int main()
{

 int a = 10000;
 FILE* pf = fopen("test.txt", "wb");
 fwrite(&a, 4, 1, pf);//⼆进制的形式写到⽂件中  
 fclose(pf);
 pf = NULL;

 return 0;
}

我们打开test.txt文件来看一下，我们发现文件里的东西我们并看不懂，这是因为默认打开的会是文本文件，观察不了二进制形式，所以我们需要在VS上打开二进制文件来看一下

打开二进制文件操作具体步骤：

图一：

图二：

解释： 我们添加现有项，点开test.txt文件添加进来后，鼠标点击test.txt右击点打开方式，然后就会出现图二这样的界面，然后我们向下找到二进制编译器，然后我们就会看到二进制形式的test.txt文件了。

三、文件的打开和关闭

3.1、流和标准流

3.1.1、流的概念

我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输⼊输出操作各不相同，为了方便程序员对各种设备进行方便的操作，我们抽象出了流的概念，我们可以把流 想象成流淌着字符的河。

C程序针对文件、画面、键盘等的数据输⼊输出操作都是通过流操作的。一般情况下，我们要想向流里写数据，或者从流中读取数据，都是要打开流，然后操作。

给大家画个图来直观感受一下：

3.1.2、标准流的概念

那为什么我们从键盘输入数据，向屏幕上输出数据，并没有打开流呢？

那是因为C语言程序在启动的时候，默认打开了3个流：

• stdin--标准输入流，在大多数的环境中从键盘输入，scanf函数就是从标准输入流中读取数据
• stdout--标准输出流，大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。
• stderr--标准错误流，大多数环境中输出到显示器界⾯。

这是默认打开了这三个流，我们使用scanf、printf等函数就可以直接进行输入输出操作的。 stdin、stdout、stderr三个流的类型是： FILE * ，通常称为文件指针。C语言中，就是通过 FILE* 的文件指针来维护流的各种操作的。

3.2、文件指针

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

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

例如，VS2013编译环境提供的 stdio.h 头文件中有以下的文件类型申明：

struct _iobuf { char *_ptr; int _cnt; char *_base; int _flag; int _file; int _charbuf; int _bufsiz; char *_tmpfname; }; typedef struct _iobuf FILE;

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。每当打开一个文件的时候，系统会根据文件的情况自动创建⼀个FILE结构的变量，并填充其中的信 息，使用者不必关心细节。 ⼀般都是通过⼀个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。下面我们可以创建⼀个FILE*的指针变量:

FILE* pf;//文件指针变量

定义pf是⼀个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够间接找到与它关联的文件。 比如：

3.3、文件的打开和关闭

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

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

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

3.3.1、fopen函数

//打开文件 FILE * fopen ( const char * filename, const char * mode );

功能： fopen 函数是用来打开参数 filename 指定的文件，同时将打开的文件和一个流进行关联， 后续对流的操作是通过 fopen 函数返回的指针来维护。具体对流（关联的文件）的操作是通过参数 mode 来指定的。

参数：

• filename ：表示被打开的文件的名字，这个名字可以绝对路径，也可以是相对路径。
• mode ：表示对打开的文件的操作方式，具体见下面的表格。

返回值：

• 若文件成功打开，该函数将返回⼀个指向 FILE 对象的指针，该指针可用于后续操作中标识对应的流。
• 若打开失败，则返回 NULL 指针，所以一定要 fopen 的返回值做判断，来验证文件是否打开成功。

#include<stdio.h>
int main()
{
//.表示当前路径	
//..表示上一级路径
	
//相对路径	
    FILE* pf = fopen("data.txt", "r");
//这里的路径是相对路径，这表示在当前工程目录下的data.txt
    FILE* pf = fopen("./../data.txt","r")
//这个文件的位置是相对于当前工程下的上一级路径的文件

//绝对路径
	FILE* pf = fopen("C:/Users/Lenovo/Desktop/data.txt", "r");
	FILE* pf = fopen("C:\\Users\\Lenovo\\Desktop\\data.txt", "r");
	
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

mode表示对打开的文件的操作方式：

3.3.2、fclose函数

int fclose ( FILE * stream );

功能： 关闭参数 stream 关联的文件，并取消其关联关系。与该流关联的所有内部缓冲区均会解除关联并刷新：任何未写入的输出缓冲区内容将被写入，任何未读取的输入缓冲区内容将被丢弃。

参数：

• stream ：指向要关闭的流的FILE 对象的指针

返回值：成功关闭 stream 指向的流会返回0，否则会返回 EOF 。

代码演示：

#include <stdio.h>
int main()
{
 FILE* fp = fopen("test.txt", "r"); 
//以“r”的形式打开⽂件，如果⽂件不存在，则打开失败 
 if(fp == NULL)
 {
 perror("fopen\n");
 return 1;
 }

四、文件的顺序读写

在进行文件读写的时候，会涉及下面这些函数，我给大家一一介绍：

4.1、fputc函数

int fputc ( int character, FILE * stream );

功能： 将参数 character 指定的字符写入到 stream 指向的输出流中，通常用于向文件或标准输出流写入字符。在写入字符之后，还会调整指示器。字符会被写入流内部位置指示器当前指向的位 置，随后该指示器自动向前移动一个位置。

参数：

• character ：被写入的字符
• stream ：是⼀个FILE*类型的指针，指向了输出流（通常是文件流或stdout）。

返回值：

• 成功时返回写入的字符（以int 形式）。
• 失败时返回EOF （通常是-1），错误指示器会被设置，可通过ferror() 检查具体错误。

代码演示：

#include <stdio.h>

int main()
{
 FILE* fp = fopen("test.txt", "w"); //以w的形式打开⽂件，才能正确的写⽂件 
 if(fp == NULL)
 {
 perror("fopen\n");
 return 1;
 }
 fputc('a', fp);
 fputc('b', fp);
 fputc('c', fp);
 
 //不再使⽤⽂件时，需要关闭⽂件 
 fclose(fp);
 fp = NULL; //将指针置为NULL,避免成为野指针。 
 return 0;
}

//也可以循环写⼊多个字符的 
#include <stdio.h>
int main()
{
 FILE* fp = fopen("test.txt", "w"); //以w的形式打开⽂件，才能正确的写⽂件 
 if(fp == NULL)
 {
 perror("fopen\n");
 return 1;
 }

 int ch = 0;
 for(ch = 'a'; ch <= 'z'; ch++)
 {
 fputc(ch, fp);
 }
 
 //不再使⽤⽂件时，需要关闭⽂件 
 fclose(fp);
 fp = NULL; //将指针置为NULL,避免成为野指针。 
 return 0;
}

//写字符到标准输出流（屏幕）
int main()
{
	fputc('a', stdout);
	fputc('b', stdout);
	fputc('c', stdout);
	fputc('d', stdout);

	//putchar('a');
	//putchar('b');
	//putchar('c');

	return 0;
}

stdout: 标准输出流，可以将其打印到屏幕上

4.2、fgetc函数

int fgetc ( FILE * stream );

功能：从参数 stream 指向的流中读取一个字符。函数返回的是文件指示器当前指向的字符，读取这个字符之后，文件指示器自动前进道下一个字符。

参数：stream :FILE*类型的文件指针，可以是 stdin ，也可以是其他输入流的指针。如果是 stdin 就从标准输入流读取数据。如果是文件流指针，就从文件读取数据。

返回值：

• 成功时返回读取的字符（以int 形式）。
• 若调用时流已处于文件末尾，函数返回EOF 并设置流的文件结束指示器（ feof ）。若发生读取错误，函数返回EOF 并设置流的错误指示器（ ferror ）。

代码演示：

//读文件
int main()
{
	//打开文件
	FILE*pf=fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}

	//读文件
	int ch=fgetc(pf);
	printf("%c", ch);
	fputc(ch, stdout);
	putchar(ch);


	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

这里我用了三种方法可以将文件中的第一个字符读取并且打印到屏幕上

//从键盘上读取
int main()
{
	
	int ch=fgetc(stdin);
	fputc(ch, stdout);

	return 0;
}

解释：这里stdin是标准输入流，可以从键盘上读取，这里我们输入a，就会给我们打印到屏幕上

4.3、feof函数和ferror函数

int feof ( FILE * stream ); //检测stream指针指向的流是否遇到文件末尾 int ferror ( FILE * stream ); //检测stream指针指向的流是否发生读/写错误

• 如果在读取文件的过程中，遇到了文件末尾，文件读取就会结束。这时读取函数会在对应的流上设置 一个文件结束的指⽰符，这个文件结束指示符可以通过 feof 函数检测到。如果 feof 函数检测到文件结束指示符已经被设置，则返回非0的值，如果没有设置则返回0。
• 如果在读/写文件的过程中，发生了读/写错误，文件读取就会结束。这时读/写函数会在对应的流上设 置一个错误指示符，这个错误指示符可以通过 ferror 函数检测到。如果 ferror 函数检测到错误指示符已经被设置，则返回非0的值，如果没有设置则返回0。

我们写一段代码来测试一下feof函数：

#include <stdio.h>
//假设test.txt⽂件中存放abcdef 
int main()
{
 FILE* fp = fopen("test.txt", "r");
 if (fp == NULL)
 {
     perror("fopen\n");
     return 1;
 }
 int i = 0;
 for (i = 0; i < 10; i++)
 {
     int c = fgetc(fp);
     if (c == EOF)
 {
 if (feof(fp))
     printf("遇到⽂件末尾了\n");
 else if (ferror(fp))
     printf("读取发⽣了错误\n");
 }
 else
 {
     fputc(c, stdout); //使⽤fputc在标准输出流上打印字符 
 }
 }
 //不再使⽤⽂件时，需要关闭⽂件 
 fclose(fp);
 fp = NULL; //将指针置为NULL,避免成为野指针。 
 return 0;
}

打印结果：

测试ferror函数：

#include <stdio.h>
//以写的形式打开⽂件后，再去读⽂件，就会发⽣错误 
int main()
{
 FILE* fp = fopen("test.txt", "w");
 if (fp == NULL)
 {
     perror("fopen\n");
     return 1;
 }
 int c = fgetc(fp);//读⽂件 
 if (c == EOF)
 {
     if (feof(fp))
         printf("遇到⽂件末尾了\n");
     else if (ferror(fp))
     {
         printf("读⽂件发⽣了错误\n");
     }
 }
 else
 {
     fputc(c, stdout); //使⽤fputc在标准输出流上打印字符 
 }

 //不再使⽤⽂件时，需要关闭⽂件 
 fclose(fp);
 fp = NULL; //将指针置为NULL,避免成为野指针。 
 return 0;
}

打印结果：

4.4、fputs函数

int fputs ( const char * str, FILE * stream );

功能：将参数 str 指向的字符串写入到参数 stream 指定的流中（不包含结尾的空字符\0 ），适用于文件流或标准输出（stdout）。

参数：

• str :str是指针，指向了要写入的字符串（必须以\0 结尾）
• stream ：是⼀个 FILE* 的指针，指向了要写入字符串的流。

返回值：

• 成功时返回非负整数。
• 失败时返回EOF （-1），同时会设置流的错误指示器，可以使用ferror() 检查错误原因。

代码演示：

int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写
	fputs("abc\n", pf);
	fputs("def", pf);
	//关闭
	fclose(pf);
	pf = NULL;
	return 0;
}

文件页面：

这里把pf换成stdout就可以打印到屏幕上去了。

4.5、fgets函数

char * fgets ( char * str, int num, FILE * stream );

功能：从 stream 指定输入流中读取字符串，至读取到换行符、文件末尾（EOF）或达到指定字符数 （包含结尾的空字符\0 ），然后将读取到的字符串存储到str指向的空间中。

参数：

• str ：是指向字符数组的指针，str指向的空间用于存储读取到的字符串。
• num ：最大读取字符数（包含结尾的\0 ，实际最多读取num-1 个字符）。
• stream ：输⼊流的文件指针（如文件流或stdin ）。

返回值：

• 成功时返回str 指针。
• 若在尝试读取字符时遇到文件末尾，则设置文件结束指示器，并返回NULL ，需通过feof() 检测。
• 若发生读取错误，则设置流错误指示器，并返回NULL，通过 ferror() 检测。

代码演示：

int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读
	char arr[20] = "xxxxxxxxxxxxxxxxx";
	fgets(arr, 5, pf);//通过调试观察，如果把pf换成stdin就从键盘上读取
	//关闭
	fclose(pf);
	pf = NULL;
	return 0;
}

这里我们借助调试来看一下：

解释： 这里文件里是abc\ndef，但是fgets要读取5个字符，但是，读到换行符就结束，这里固然就把换行符也读进去了，并且末尾又补了个\0。

我们再来看一个例子：

解释： 这里我把文件改为了abcd，此时调试发现没有了\n，这里就可以验证fgets读取的时候确实包含\0

4.6、fprintf函数

int fprintf ( FILE * stream, const char * format, ... ); //类⽐printf函数学习 int printf ( const char * format, ... ); fprintf函数比printf函数多了一个参数

功能：fprintf 是将格式化数据写入指定文件流的函数。它与 printf 类似，但可以输出到任意文件（如磁盘文件、标准输出、标准错误等），而不仅限于控制台。

参数：

• stream ：指向FILE 对象的指针，表示要写入的文件流（如stdout 、⽂件指针等）。
• format ：格式化字符串，包含要写入的文本和格式说明符（如%d 、 %s 等）。
• ... ：可变参数列表，提供与格式字符串中说明符对应的数据。

返回值：

• 成功时，返回写入的字符总数（非负值）。
• 失败时，先设置对应流的错误指示器，再返回负值，可以通过 ferror() 来检测。

代码演示：

//fprintf
struct stu
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct stu s = { "zhangsan",19,88.5 };
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fprintf(pf, "%s %d %.2f\n", s.name, s.age, s.score);
	//与scanf相比就多了个流参数，这里把pf改为stdout就把打印到屏幕上了
	fclose(pf);
	pf = NULL;
	return 0;
}

打印结果：

4.7、fscanf函数

int fscanf ( FILE * stream, const char * format, ... ); //类比scanf函数来学习 int scanf ( const char * format, ... ); 这里fscanf就比scanf多了一个参数

功能：fscanf 是从指定文件流中读取格式化数据的函数。它类似于scanf ，但可以指定输入源 （如文件、标准输入等），而非仅限于控制台输入。适用于从文件解析结构化数据（如整数、浮点 数、字符串等）。

参数：

• stream ：指向FILE 对象的指针，表示要读取的文件流（如stdin 、文件指针等）。
• format ：格式化字符串，定义如何解析输入数据（如%d 、 %f 、 %s 等）。
• ... ：可变参数列表，提供存储数据的变量地址（需与格式字符串中的说明符匹配）。

返回值：

成功时，函数返回成功填充到参数列表中的项数。该值可能与预期项数一致，也可能因以下原因少 于预期（甚至为零）：

• 格式和数据匹配失败；
• 读取发生错误；
• 到达文件末尾（EOF）。

如果在成功读取任何数据之前发⽣：

• 发生读取错误，会在对应流上设置错误指示符，则返回EOF 。
• 到达文件末尾，会在对应流上设置文件结束指示符，则返回EOF 。

代码演示：

在fprintf函数学习的时候，已经向文件中写入了数据： zhangsan 20 85.5 ，我们现在想在文件中读取这些数据出来。

//fscanf
int main()
{
	struct stu t = { 0 };
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}

	int r = fscanf(pf, "%s %d %f", t.name, &(t.age), &(t.score));
	//有几项，r=几，如果有没读到的有几个就是几
	printf("%s %d %.2f\n", t.name, t.age, t.score);
	printf("r=%d", r);
	fclose(pf);
	pf = NULL;
	return 0;
}

打印结果：

解释： fscanf返回值为整型，所以这里拿r来接收fscanf的返回值，这里读到几个参数就返回几，所以这里返回3。

4.8fwrite函数

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

功能：函数用于将数据块写入 stream 指向的文件流中，是以二进制的形式写入的。

参数：

• ptr ：指向要写入的数据块的指针。
• size ：要写入的每个数据项的大小（以字节为单位）。
• count ：要写入的数据项的数量。
• stream ：指向FILE 类型结构体的指针，指定了要写入数据的文件流。

返回值： 返回实际写入的数据项数量。如果发生错误，则返回值可能小于count 。

使用时注意事项：

• 需要包含<stdio.h>头文件。
• 在使用fwrite() 之前，需要确保文件已经以二进制可写方式打开。
• fwrite() 通常用于二进制数据的写入，如果写入文本数据，请谨慎处理换行符和编码等问题。

代码演示：

//二进制写结构体
struct Stu
{
	char name[20];
	int age;
};
int main()
{
	struct Stu s = { "张三",19 };
	FILE* pf = fopen("data1.txt", "wb");//二进制写
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//使用
	fwrite(&s, sizeof(struct Stu), 1, pf);
	//关闭
	fclose(pf);
	pf = NULL;
	return 0;
}

结果：

//二进制写数组
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	FILE* pf = fopen("data.txt", "wb");//二进制写
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//使用
	if (fwrite(arr, sizeof(arr), 1, pf) != 5)
	{
		perror("fwrite");
		return 1;
	}
	//关闭
	fclose(pf);
	pf = NULL;
	return 0;
}

4.9fread函数

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

功能：函数用于从 stream 指向的文件流中读取数据块，并将其存储到 ptr 指向的内存缓冲区中。

参数：

• ptr ：指向内存区域的指针，用于存储从文件中读取的数据。
• size ：要读取的每个数据块的大小（以字节为单位）。
• count ：要读取的数据块的数量。
• stream ：指向FILE类型结构体的指针，指定了要从中读取数据的文件流。

返回值：返回实际读取的数据块数量。

使用时注意事项：

• 需要包含<stdio.h> 头文件。
• 在使用fread() 之前，需要确保文件已经以二进制可读方式打开。
• ptr 指向的内存区域必须足够大，以便存储指定数量和大小的数据块。
• 如果fread() 成功读取了指定数量的数据块，则返回值等于count ；如果读取数量少于count ，则可能已经到达文件结尾或者发生了错误。
• 在二进制文件读取时， fread() 是常用的函数，但对于文本文件读取，通常使用fgets() 或fscanf() 。

代码演示：

//fread
struct Stu
{
	char name[20];
	int age;
};
int main()
{
	struct Stu s = { 0 };
	FILE* pf = fopen("data.txt", "rb");//二进制写
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//使用
	size_t r=fread(&s, sizeof(struct Stu), 1, pf);
	if (r != 1)
	{
		if (feof(pf))
		{
			printf("遇到了文件末尾\n");
		}
		else if (ferror(pf))
		{
			printf("读取错误\n");
		}
	}
	else
	{
		printf("%s %d", s.name, s.age);
	}
	
	//关闭
	fclose(pf);
	pf = NULL;
	return 0;
}

解释： 文件这里原来存放的我们之前输入的结构体的信息，当我们运行后，文件里结构体的信息就打印出来了。

五、sprintf函数和sscanf函数

5.1、sprintf、printf、fprintf和sscanf、scanf、fscanf函数对比

我们在上面学习了以上四种函数，下面我们将学习sprintf函数与sscanf函数

5.2、sprintf函数

int sprintf ( char * str, const char * format, ... );

功能：将格式化数据写入字符数组（字符串）。它类似于printf ，但输出目标不是控制台或文件， 而是用户指定的内存缓冲区。常用于动态生成字符串、拼接数据或转换数据格式。简而言之就是将格式化的数据转换成一个字符串。

参数：

• str ：指向字符数组的指针，⽤于存储生成的字符串（需确保足够大以防止溢出）。
• format ：格式化字符串，定义输出格式（如%d 、 %f 、 %s 等）。
• ... ：可变参数列表，提供与格式字符串中说明符对应的数据。

返回值：

• 成功时：返回写入buffer 的字符数（不包括结尾的空字符\0 ）。
• 失败时：返回负值。

代码演示：

//sprintf
struct Stu
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct Stu s = { "zhangsan",10,99.5 };
	char buffer[100] = { 0 };
	sprintf(buffer, "%s %f %d", s.name, s.score, s.age);
	printf("%s\n", buffer);
	
	return 0;
}

打印结果：

5.3、sscanf函数

int sscanf ( const char * str, const char * format, ...);

功能：从字符串中读取格式化数据。它与scanf 类似，但输入源是内存中的字符串而非控制台或文 件。常用于解析字符串中的结构化数据（如提取数字、分割文本等）。

参数：

• str ：要解析的源字符串（输入数据来源）。
• format ：格式化字符串，定义如何解析数据（如%d 、 %f 、 %s 等）。
• ... ：可变参数列表，提供存储数据的变量地址（需与格式字符串中的说明符匹配）

返回值：

• 成功时：返回成功解析并赋值的参数数量（非负值）。
• 失败或未匹配任何数据：若输入结束或解析失败，返回EOF （通常是-1 ）。

代码演示：

//sscanf
struct Stu
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct Stu s = { "zhangsan",10,99.5 };
	char buffer[100] = { 0 };
	sprintf(buffer, "%s %f %d", s.name, s.score, s.age);
	printf("%s\n", buffer);
	struct Stu t = { 0 };
	sscanf(buffer, "%s %f %d", t.name, &(t.score), &(t.age));
	//sscnaf读取的时候顺序不能变
	printf("%s %f %d\n", t.name, t.score, t.age);
	//打印的时候可以不按顺序打印
	return 0;
}

打印结果：

六、文件的随机读写

6.1、fseek函数

int fseek ( FILE * stream, long int offset, int origin );

功能：根据文件指针的位置和偏移量来定位指针

参数：

• stream：指向 FILE 类型结构体的指针，指定了要操作的文件流。
• offset：表示偏移量，以字节为单位。
• origin：指定偏移量的起始位置

origin的三种取值：

返回值：

• 成功时返回0
• 失败时返回非0，并设置errno来表示错误类型

代码演示：

//fseek--根据文件指针的位置和偏移量来定位文件指针（文件内容的光标）
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int ch = fgetc(pf);
	printf("%c\n", ch);
	fseek(pf, 6, SEEK_SET);//SEEK_SET起始位置//g
	ch = fgetc(pf);
	printf("%c\n", ch);
	fseek(pf, 5, SEEK_CUR);//SEEK_CUR光标移动到的位置//g
	ch = fgetc(pf);
	printf("%c\n", ch);
	fseek(pf, -3, SEEK_END);//SEEK_END最终位置//g
	ch = fgetc(pf);
	printf("%c\n", ch);

	fclose(pf);
	pf = NULL;

	return 0;
}

文件展示：

打印结果：

6.2、ftell函数

long int ftell ( FILE * stream );

功能：返回文件指针相对于起始位置的偏移量，单位为：字节

参数：stream：指向 FILE 类型结构体的指针，指定要操作的文件流

返回值：

• 成功时，返回文件指针相对于文件开头的字节数
• 失败时，返回-1，并设置errno来指示错误类型

代码演示：

//ftell--返回文件指针相对于起始位置的偏移量
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fputs("abcdefghi", pf);
	fseek(pf, 6, SEEK_SET);
	fputc('x', pf);
	int ret = ftell(pf);
	printf("偏移量：%d", ret);//7

	return 0;
}

打印结果：

6.3、rewind函数

void rewind ( FILE * stream );

功能：让文件指针的位置回到文件的起始位置

参数：stream：指向 FILE 类型结构体的指针，指定要操作的文件流

代码演示：

//ftell--返回文件指针相对于起始位置的偏移量
//rewind--文件指针回到起始位置
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fputs("abcdefghi", pf);
	fseek(pf, 6, SEEK_SET);
	fputc('x', pf);
	int ret = ftell(pf);
	printf("偏移量：%d", ret);//7
	rewind(pf);//指针就回到起始位置了
	fputc('w', pf);

	return 0;
}

文件展示：

解释： rewind函数将文件指针回到起始位置，fputc函数将'w'字符放在'a'位置上，取代了'a'。

七、文件缓冲区

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

图解：

7.1、fflush函数

int fflush ( FILE * stream );

功能：强制刷新参数 stream 指定流的缓冲区，确保数据写入底层设备。

• 对输出流：将缓冲区中未写入的数据立即写入文件。
• 对输入流：行为由具体实现决定，非C语言标准行为（可能清空输入缓冲区）
• 参数为 NULL 时：刷新所有打开的输出流

参数：

stream ：指向文件流的指针（如 stdout 、文件指针等）

返回值：成功返回 0 ，失败返回 EOF。

代码演示：

#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试 
int main()
{
 FILE*pf = fopen("data.txt", "w");
 fputs("abcdef", pf);//先将代码放在输出缓冲区 
 printf("睡眠10秒-已经写数据了，打开data.txt⽂件，发现⽂件没有内容\n");
 Sleep(10000);
 printf("刷新缓冲区\n");
 fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到⽂件（磁盘） 
 //注：fflush 在⾼版本的VS上不能使⽤了 
 printf("再睡眠10秒-此时，再次打开data.txt⽂件，⽂件有内容了\n");
 Sleep(10000);
 fclose(pf);
 //注：fclose在关闭⽂件的时候，也会刷新缓冲区 
 pf = NULL;
 return 0;
}

结果展示：

图一：

图二：

结论： 因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。 如果不做，可能导致读写文件的问题。

八、更新文件

在文件的打开模式中有三种方式值得注意，分别是:"r+","w+","a+"，分别是什么意思？

关键要点：

1. 在写完文件后，要继续读文件的时候，在读取之前⼀定要使用 fflush() 刷新文件缓冲区，或者使用fseek() ， rewind() 重新定位文件指示器的位置。
2. 在读完文件后，需要继续写文件之前，在写文件之前，使用fseek() ， rewind() 重新定位文 件指示器的位置。

代码演示：

#include <stdio.h>
int main()
{
 FILE* fp = fopen("data.txt", "w+");
 if (fp == NULL)
 {
 perror("fopen for w+");
 return 1;
 }
 //写abcdefghi到⽂件中 
 fputs("abcdefghi", fp);
 //刷新缓冲区，保证数据写⼊⽂件 
 fflush(fp);
 //要读取数据b字符，先定位⽂件指针 
 fseek(fp, 1, SEEK_SET);
 int ch = fgetc(fp);//读取字符 
 printf("%c\n", ch);
 //在b的位置开始写⼊hello 
 fseek(fp, -1, SEEK_CUR);
 //解释：因为前⾯读取⼀个字符后,⽂件指⽰器现在指向了c,需要从当前位置退回⼀个字符 
 fputs("hello", fp);
 //关闭⽂件 
 fclose(fp);
 fp = NULL;
 return 0;
}

文件展示：

总结： 这篇文章给大家总结了一系列的文件的知识、函数和注意事项，希望大家看完这篇文章能够有所收获，并且要自己多加练习，反复理解透彻这些函数。

如果这篇文章让大家对文件操作这方面知识有扩展和新的认识，希望大家给博主一键三连，你们的支持是我最大的动力，感谢大家的支持🌹🌹🌹