【c语言进阶】文件操作（上）

喜欢ヅ旅行 2024-04-26 11:06 81阅读 0赞

![在这里插入图片描述][6ac7346dc5944908b5dd227e55fab217.gif_pic_center]

> ?write in front?  
> ?所属专栏：> [c语言学习][c]  
> ?️博客主页：[睿睿的博客主页][Link 1]  
> ?️代码仓库：?[VS2022\_C语言仓库][VS2022_C]  
> ?您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！  
> **关注我，关注我，关注我**，你们将会看到更多的优质内容！！

![在这里插入图片描述][85d8f838a7524c8bb8bed80b7ac059c1.gif_pic_center]

#### 文章目录 ####

*  ?前言?：
 *  一、文件概述：
 *   *  1.什么是文件：
     *   *  1.1.程序文件：
         *  1.2数据文件：
         *  1.3文件名：
         *   *  1.3.1绝对路径：
             *  1.3.2相对路径：
 *  二、文件的打开和关闭：
 *   *  1.文件指针：
     *  2.文件的打开与关闭：
     *  3.文件的打开方式：
 *  三、文件的顺序读写：
 *   *  1.字符的读与写 fgetc 与 fputc:
     *   *  字符的读取函数 fputc :
         *  字符的读取函数 fgetc :
         *  组合应用：
     *  2.文本行的读与写 fgets 与 fputs
     *   *  fputs读取字符串:
         *  fgets读取字符串:
     *  3.格式化输出函数 fscanf和fprintf：
     *   *  fprintf的格式化写入：
         *  fscanf的格式化读取：
     *  4.二进制的输入与输出fwead和fwrite：
     *   *  二进制的输出fwrite：
         *  二进制的输入fread：
     *  5.流的概念：
     *  6.辨析输入与输出：
     *  7.辨析三组函数：
     *   *  7.1.scanf和printf：
         *  7.2.fscanf和fprintf:
         *  7.3.sscanf和sprintf
 *  ?总结?：

## ?前言?： ##

在前面的通讯录学习中，我们发现，**当程序结束以后，内存空间就会被释放并回收**，我们所存的通讯录人的消息就全部消失了。如此，**我们无法将数据真正保留下来。**  
  所以，我们的目的便是希望将数据保留在本地，只有当我们进行删除操作时，才将对应的数据删除掉，即尝试实现数据的持久化。而我们实现数据持久化的方式一般有两种：使用 数据库 或将数据以 文件操作 存放至**硬盘**中。今天我们就来学习一下**文件操作**相关知识。

## 一、文件概述： ##

### 1.什么是文件： ###

我们通常所说的文件，一般是指存放在我们计算机本地硬盘上的文件。但是在我们的程序设计中，则指的是 程序文件 与 数据文件 两种文件（根据文件功能分类）。

#### 1.1.程序文件： ####

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

#### 1.2数据文件： ####

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

本章讨论的是数据文件。  
  在以前各章所处理数据的输入输出都是以**终端**为对象的，即从终端**加粗样式**的键盘输入数据，运行结果显示到**显示器**上。而今天我们的目的则是将数据信息输入至我们的**本地磁盘**上，而当我们想要对数据进行操作时，再**从本地硬盘进行读取**。

#### 1.3文件名： ####

##### 1.3.1绝对路径： #####

一个文件要有一个唯一的文件标识，以便用户识别和引用。绝对路径的文件名包含3部分：**文件路径+文件名主干+文件后缀**  
例如： c:\\code\\test.txt  
为了方便起见，文件标识常被称为文件名。

##### 1.3.2相对路径： #####

如果打开所在文件路径的文件，则**不用前面的文件路径**  
例如： test.txt  
  如果要打开所在文件的**上一层文件**，则在前面＋一个 . ./ ;  
例如： . ./test.txt  
同理，如果是**上上一层文件**，则＋ . ./. ./

![在这里插入图片描述][c7ed1fe682c5474b8f40abd7df3f14f1.png]

## 二、文件的打开和关闭： ##

我们在使用或操作我们的文件之前，首先需要在我们的程序中及将其打开，于是我们就来研究一下文件的打开和关闭方式。

### 1.文件指针： ###

**缓冲文件**系统中，关键的概念是“文件类型指针”，简称“**文件指针**”。  
  每个文件在被使用时，都会在**内存中开辟**了一个相应的**文件信息区**，用来**存放文件**的**相关信息**（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个**结构体变量**中的。该结构体类型是**有系统声明的，取名FILE.**  
![在这里插入图片描述][8315742ecea54034853eb1642435e58b.png]

例如，VS2022编译环境提供的 stdio.h 头文件中有以下的文件类型申明  
![在这里插入图片描述][1cec3229c2ed4ed19f5198b9d8129ab9.png]  
此时结构体内的指针**指向保存文件信息的成员**。

**每当打开一个文件**的时候，**系统会根据文件的情况自动创建一个FILE结构的变量**，**并填充其中的信息** ，使用者不必关心细节。  
  一般都是通过一个**FILE的指针**来维护这个FILE结构的变量，这样使用起来更加方便。  
下面我们可以创建一个FILE\*的指针变量：

FILE* p;
    //定义一个文件指针p

像这样，我们就能创建出一个文件指针，而接下来就可以使这个文件**指针** p 指向某个**文件信息区**（FILE 类型的结构体变量），并通过该**文件信息区**中所保存的信息来**访问本地硬盘内的文件**了。这样，**我们通过使用文件指针就可以找到与其相关联的文件了**。

### 2.文件的打开与关闭： ###

文件在读写之前应该**先打开文件**，在使用结束之后应该**关闭文件**。  
在编写程序的时候，在打开文件的同时，都会返回一个**FILE\*的指针变量**指向该文件，也相当于建立了指针和文件的关系。  
ANSIC 规定使用**fopen函数**来打开文件，**fclose**来关闭文件.

**fopen 函数的使用方式：**

FILE* p = fopen(const char* filename, const char* mod);

*  其中“ const char\* filename ”指**文件名**（是字符串，文件名即文件标识符\*\*）。
 *  其中“ const char\* mod ”指文件**打开模式**（也是**字符串，后面会为大家列出**）。
 *  返回值：若成功，返回一个文件指针，若文件打开失败，则返回一个空指针

**fclose 函数的使用方式为：**

fopen(FILE* strname);

*  参数 FILE \*stream : 这是指向 FILE 对象的指针，**该 FILE 对象指定了要被关闭的流;**
 *  返回值：若文件关闭成功，则返回0；  
        若文件关闭失败，则返回EOF；  
    **举个栗子?**

int main()
    {
        
    	//D:\\code\\test.txt - 绝对路径
    	//
    	FILE* pf = fopen("test2.txt", "w");
    	if (pf == NULL)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	else
    	{
        
    		printf("打开文件成功\n");
    	}
    	//读文件
    	//....
    
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    
    	return 0;
    }

### 3.文件的打开方式： ###

<table> 
 <thead> 
  <tr> 
   <th>文件使用方式</th> 
   <th>含义</th> 
   <th>如果指定文件不存在</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>“r”（只读）</td> 
   <td>为了输入数据，打开一个已经存在的文本文件</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td>“w”（只写）</td> 
   <td>为了输出数据，打开一个文本文件（会清除文件里的消息）</td> 
   <td>建立一个新的文件</td> 
  </tr> 
  <tr> 
   <td>“a”（追加）</td> 
   <td>向文本文件尾添加数据</td> 
   <td>建立一个新的文件</td> 
  </tr> 
  <tr> 
   <td>“rb”（只读）</td> 
   <td>为了输入数据，打开一个二进制文件</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td>“wb”（只写）</td> 
   <td>为了输出数据，打开一个二进制文件</td> 
   <td>建立一个新的文件</td> 
  </tr> 
  <tr> 
   <td>“ab”（追加）</td> 
   <td>向一个二进制文件尾添加数据</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td>“r+”（读写）</td> 
   <td>为了读和写，打开一个文本文件</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td>“w+”（读写）</td> 
   <td>为了读和写，建议一个新的文件</td> 
   <td>建立一个新的文件</td> 
  </tr> 
  <tr> 
   <td>“a+”（读写）</td> 
   <td>打开一个文件，在文件尾进行读写</td> 
   <td>建立一个新的文件</td> 
  </tr> 
  <tr> 
   <td>“rb+”（读写）</td> 
   <td>为了读和写打开一个二进制文件</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td>“wb+”（读写）</td> 
   <td>为了读和写，新建一个新的二进制文件</td> 
   <td>建立一个新的文件</td> 
  </tr> 
  <tr> 
   <td>“ab+”（读写）</td> 
   <td>打开一个二进制文件，在文件尾进行读和写</td> 
   <td>建立一个新的文件</td> 
  </tr> 
 </tbody> 
</table>

## 三、文件的顺序读写： ##

<table> 
 <thead> 
  <tr> 
   <th>功能</th> 
   <th>函数名</th> 
   <th>适用于</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字符输入函数</td> 
   <td>fgetc</td> 
   <td>所有输入流</td> 
  </tr> 
  <tr> 
   <td>字符输出函数</td> 
   <td>fputc</td> 
   <td>所有输出流</td> 
  </tr> 
  <tr> 
   <td>文本行输入函数</td> 
   <td>fgets</td> 
   <td>所有输入流</td> 
  </tr> 
  <tr> 
   <td>文本行输出函数</td> 
   <td>fputs</td> 
   <td>所有输出流</td> 
  </tr> 
  <tr> 
   <td>格式化输入函数</td> 
   <td>fscanf</td> 
   <td>所有输入流</td> 
  </tr> 
  <tr> 
   <td>格式化输出函数</td> 
   <td>fprintf</td> 
   <td>所有输出流</td> 
  </tr> 
  <tr> 
   <td>二进制输入</td> 
   <td>fread</td> 
   <td>文件</td> 
  </tr> 
  <tr> 
   <td>二进制输出</td> 
   <td>fwrite</td> 
   <td>文件</td> 
  </tr> 
 </tbody> 
</table>

### 1.字符的读与写 fgetc 与 fputc: ###

#### 字符的读取函数 fputc : ####

![在这里插入图片描述][9f1f3660483c4ea9944773f211554e79.png]

*  描述 ：把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动;
 *  参数 int char ：这是**要被写入的字符**。该字符**以其ASCII 值进行传递**；
 *  参数 FILE \*stream ： 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符的流；
 *  返回值：该函数以无符号 char 强制转换为 int 的形式（**即字符的ASCII值**）返回写入的字符，如果**发生错误则返回 EOF.**

int main()
    {
        
    	FILE* pf = fopen("test.txt", "w");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//写文件
    	/*fputc('a', pf);
    	fputc('b', pf);
    	fputc('c', pf);
    	fputc('d', pf);*/
    
    	char ch = 0;
    	for (ch = 'a'; ch <= 'z'; ch++)
    	{
        
    		fputc(ch, pf);
    	}
    
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    
    	return 0;
    }

**运行结果：**  
![在这里插入图片描述][0de5856198424a358dc04d9c9e4a2fbb.png]  
  这就是字符的写入，大家会在该项目找到这个文件。

#### 字符的读取函数 fgetc : ####

![在这里插入图片描述][5c00c227a7214751ac133028e14a08e8.png]

*  参数 FILE \*stream ：这是**指向 FILE 对象的指针**，该 FILE 对象标识了要在上面执行操作的流；
 *  返回值：该函数以无符号 char 强制转换为 **int 的形式返回读取的字符**，如果到达**文件末尾**或发生**读错误**，**则返回 EOF。**

我们在上面代码的基础下展示文件的读取。

int main()
    {
        
    	FILE* pf = fopen("test.txt", "r");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//读文件
    	int ch = fgetc(pf);
    	printf("%c\n", ch);
    
    	ch = fgetc(pf);
    	printf("%c\n", ch);
    
    	ch = fgetc(pf);
    	printf("%c\n", ch);
    
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    
    	return 0;
    }

**运行结果：**  
![在这里插入图片描述][0210caa126c9414891e61ade13549fe6.png]  
**注意：**

*  getc函数对于字符的读取，每读取一个字符，该函数内的指针会自动将指向的位置向后移动，指向下一个字符；

#### 组合应用： ####

int main()
    {
        
    	FILE* pf = fopen("test.txt", "w");  //以只写的方式打开文件
    	if (pf == NULL)
    	{
        
    		perror("fopen");
    		return 0;
    	}
    	char ch = 0;
    	for (ch = 'a'; ch <= 'z'; ch++)   //向文件写入26个小写英文字母
    	{
        
    		fputc(ch, pf);
    	}
    	fclose(pf);
    	pf = NULL;
    	pf= fopen("test.txt", "r");  //以只读的方式打开文件
    	if (pf== NULL)
    	{
        
    		perror("fopen");
    		return 0;
    	}
    	while (ch != EOF)   //判断是否读取到文件末尾
    	{
        
    		ch = fgetc(pf);   //从文件中读取字符
    		printf("%c", ch);   //打印读取字符
    	}
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

**代码结果：**  
![在这里插入图片描述][cd71ebee3d2f4cebbd3780705c691da5.png]

### 2.文本行的读与写 fgets 与 fputs ###

#### fputs读取字符串: ####

![在这里插入图片描述][ac113f9dfb474ffea1587a120fd01d28.png]

*  参数 const char \*str : 这是一个字符串，有’\\0’结尾。
 *  参数 FILE \*stream : 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符串的流;
 *  返回值：该函数返回一个非负值，如果发生错误则返回 EOF。

int main()
    {
        
    	FILE* pf = fopen("test.txt", "w");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//写文件
    	//测试写一行数据
    	fputs("hello world\n", pf);
    	fputs("hello bit\n", pf);
    
    	return 0;
    }

**运行结果：**  
![在这里插入图片描述][341664b255a14d02a064e345af4906fc.png]

#### fgets读取字符串: ####

![在这里插入图片描述][c099aa4e191f4f948c8e10fd2846b5f9.png]

*  描述： 从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。
 *  参数 char \*str ：这是指向一个指针，该指针指向了要读取的字符串；
 *  参数 int n : 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度;
 *  参数 FILE \*stream ：这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流；
 *  返回值：如果成功，该函数返回相同的 str 参数；如果到达文件末尾或者没有读取到任何字符，str 的内容保持不变，并返回一个空指针；如果发生错误，返回一个空指针；

**特殊情况：**

*  当**读取 (n-1) 个字符时，****会自动在第n个位置补’\\0’**
 *  **读取到换行符时**，会把’\\n’之前的字符读取出来然后补’\\0’，但是不会读到’\\n’，**具体情况在后面的缓冲区部分知识里会提到**。此时的’\\n’会在保存在下一个fgets函数的第一个字符
 *  **到达文件末尾**时，它会停止，具体视情况而定.

int main()
    {
        
    	FILE* pf = fopen("test.txt", "r");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//读文件
    	//测试一行数据
    	char buf[20] = {
        0};
    	fgets(buf, 20, pf);
    	printf("%s", buf);
    	fgets(buf, 20, pf);
    	printf("%s", buf);
     	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

**代码结果：**  
![在这里插入图片描述][0a830109ede04570af82f32a8de047c4.png]

### 3.格式化输出函数 fscanf和fprintf： ###

#### fprintf的格式化写入： ####

![在这里插入图片描述][581997abad95451fb78b2946f6a7bd17.png]  
  其实该函数和printf函数一模一样，只是**前面多了一个指向文件的指针！** 这里的意思其实是将后面的数据**以不同的格式**写入**指针指向的文件信息中。**

struct S
    {
        
    	char name[20];
    	int age;
    	float score;
    };
    
    int main()
    {
        
    	struct S s = {
         "zhangsan", 20, 95.5 };
    	FILE* pf = fopen("test.txt", "w");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//格式化的写入文件
    	fprintf(pf, "%s %d %f\n", s.name, s.age, s.score);
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

**运行结果：**  
![在这里插入图片描述][f8aacf4a62d8432bb6673b39a0c5d8c4.png]

#### fscanf的格式化读取： ####

![在这里插入图片描述][9d80560669ad4b25913bfe8aef2e5f67.png]  
  一样的，都是多了一个文件指针而已，其他都是一模一样的！这里的意思是将**文件指向的文件消息**以**不同格式**读出并且**保存在不同类型的变量中。**

int main()
    {
        
    	struct S s = {
         0 };
    	FILE* pf = fopen("test.txt", "r");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//格式化的读取文件
    	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));
    	
    	//打印看数据
    	printf("%s %d %f\n", s.name, s.age, s.score);
    	
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

**运行结果：**  
![在这里插入图片描述][42328680c0cd40dcaa820f7fc9fe070f.png]

### 4.二进制的输入与输出fwead和fwrite： ###

#### 二进制的输出fwrite： ####

![在这里插入图片描述][2e9269e8d8b94150a2d19eb3caf4c8d0.png]

*  **描述**：把 ptr 所指向的数组中的数据写入到给定流 stream 中；
 *  **参数 void (\*)ptr** ：这是指向带有最小尺寸 size\*nmemb 字节的内存块的指针；
 *  **参数 size\_t size** ：这是要读取的每个元素的大小，以字节为单位；
 *  **参数 size\_t count** ：这是元素的个数；
 *  **参数 FILE(\*)stream** : 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流;
 *  **返回值**：如果**成功**，该函数**返回一个 size\_t 对象**，表示**元素的总数**，该对象是一个整型数据类型。

int main()
    {
        
    	struct S s = {
         "张三", 20, 98.5};
    	FILE* pf = fopen("test.txt", "wb");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//写文件
    	fwrite(&s, sizeof(struct S), 1, pf);
    
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

![在这里插入图片描述][111796a05e584c23bb42fa7b7cc10fdd.png]  
**文本形式是这样的：**  
![在这里插入图片描述][dd62b5f18a3c4d3ebc6c500a90942527.png]  
但是我们转出2进制看就是这样的：  
![在这里插入图片描述][0d06639730294c33974e075248192a92.png]  
![在这里插入图片描述][e92ab86eb97d449cb251c6c10494ffe6.png]

#### 二进制的输入fread： ####

![在这里插入图片描述][37d27ab25dd44cd48b0cb20716a767c1.png]

*  **描述**：从给定流 stream 读取数据到 ptr 所指向的空间中；
 *  **参数 void (\*)ptr** ：这是指向带有最小尺寸 size\*nmemb 字节的内存块的指针；
 *  **参数 size\_t size** ：这是要读取的每个元素的大小，以字节为单位；
 *  **参数 size\_t nmemb** ：这是元素的个数；
 *  **参数 FILE(\*)stream** : 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流;
 *  **返回值** ：成功读取的元素总数会以 size\_t 对象返回，size\_t 对象是一个整型数据类型。如果返回值小于元素个数 ，则发生了错误或读到文件末尾。

int main()
    {
        
    	struct S s = {
         0};
    	FILE* pf = fopen("test.txt", "rb");
    	if (NULL == pf)
    	{
        
    		perror("fopen");
    		return 1;
    	}
    	//读文件
    	fread(&s, sizeof(struct S), 1, pf);
    	printf("%s %d %f\n", s.name, s.age, s.score);
    
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

**代码结果：**  
![在这里插入图片描述][29e7a0be02134ef4aaf1e07a873c44e0.png]

### 5.流的概念： ###

![在这里插入图片描述][a0c6acfcc3dc4db49fd07e16560a30d4.png]

小伙伴对于上面所提到的输入流输出流肯定非常迷惑。可以看到流其实流是一个极其抽象的概念，我们可以把它理解成C程序与外部设备进行交流的一个媒介，**文件**是一个流，我们的**键盘**，**屏幕**也是一个流，并且他们有各自专门的文件指针的名称。  
其实我们也可以用**上面的fprintf**，**fscanf来实现printf和scanf**

struct S
    {
        
    	char name[20];
    	int age;
    	float score;
    };
    
    int main()
    {
        
    	struct S s = {
         0 };
    	fscanf(stdin, "%s %d %f", s.name, &(s.age), &(s.score));
    	fprintf(stdout, "%s %d %f\n", s.name, s.age, s.score);
    
    	//int ch = fgetc(stdin);
    	//fputc(ch, stdout);
    
    	return 0;
    }

### 6.辨析输入与输出： ###

在这里，为了方便辨析是输入还是输出。我们可以**把自己当作内存**！**以内存为主体**来**判断是输出还是输入**。比如键盘上打字对于内存来说是输入/读取，在屏幕上打印是输出/写入。写文件是将内存的东西放入文件是输出/写入，从文件获取信息是输入/读取。  
![在这里插入图片描述][d55ae011846f45aab08bb066bd406798.png]

### 7.辨析三组函数： ###

#### 7.1.scanf和printf： ####

*  scanf —从键盘上读取格式化的数据 stdin
 *  printf —把数据写到（输出）屏幕上 stdout

#### 7.2.fscanf和fprintf: ####

*  fscanf —针对所有输入流的格式化的输入函数：stdin，打开的文件
 *  fsprintf —针对所有输出流的格式化的输出函数：stdout，打开的文件

#### 7.3.sscanf和sprintf ####

*  **s**scanf —从一个字符串中，还原一个格式化的数据
 *  **s**printf —把格式化的数据，存放在（转化成）一个字符串

相信大家看到前面的s就知道肯定是和字符串有关，其实这两个函数就是将格式化数据和字符串数据相互转化罢了，看一个栗子?就够了！

int main()
    {
        
    	struct S s = {
        "zhangsan", 20, 98.5};
    	char buf[100] = {
         0 };
    	//转化成字符串形式
    	sprintf(buf, "%s %d %f", s.name, s.age, s.score);
    	//按照字符串打印的
    	printf("%s\n", buf);
    
    	struct S tmp = {
         0 };
    	//转化为格式化数据
    	sscanf(buf, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
    	//打印结构体数据
    	printf("%s %d %f\n", tmp.name, tmp.age, tmp.score);
    
    	return 0;
    }

## ?总结?： ##

今天介绍了文件的一些基本知识，对于随机读取，缓冲区的相关知识我将会在下一篇文章讲解！  
  更新不易，辛苦各位小伙伴们动动小手，?三连走一走?? ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

> **专栏订阅：**  
> [每日一题][Link 2]  
> [c语言学习][c]  
> [算法][Link 3]  
> [智力题][Link 4]  
> 更新不易，辛苦各位小伙伴们动动小手，?三连走一走?? ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

![在这里插入图片描述][55270e2552774a17a711aa978da84193.gif_pic_center]

[6ac7346dc5944908b5dd227e55fab217.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7a7f655eca0147d29e226cba0fd21233.gif
[c]: https://blog.csdn.net/qq_74310471/category_12157207.html?spm=1001.2014.3001.5482
[Link 1]: https://blog.csdn.net/qq_74310471?spm=1000.2115.3001.5343
[VS2022_C]: https://gitee.com/zhangxuruihhhh/c-language-learning
[85d8f838a7524c8bb8bed80b7ac059c1.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e0ba1da5d4f2472ca34178268b4d4ee2.gif
[c7ed1fe682c5474b8f40abd7df3f14f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7a46012be9484be990d42c8b5e4457d9.png
[8315742ecea54034853eb1642435e58b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/124dabc686c64b00a6c13c13b3031b08.png
[1cec3229c2ed4ed19f5198b9d8129ab9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8af8b3552281406690967f2691d34cdd.png
[9f1f3660483c4ea9944773f211554e79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/77b0be51d9fe47f9a7ec9b082b0403f5.png
[0de5856198424a358dc04d9c9e4a2fbb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e072ddddfc4349a199993f602bbd64a6.png
[5c00c227a7214751ac133028e14a08e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a76dbfa269604fbfbaa0625cdfec5ee2.png
[0210caa126c9414891e61ade13549fe6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e207b0afa7e545dba233493b3c8d7cfb.png
[cd71ebee3d2f4cebbd3780705c691da5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/cf60225a1aa54445a6cf6f107737040d.png
[ac113f9dfb474ffea1587a120fd01d28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/b7fa13d0a7ec43fa8cda9c1d88bfedf6.png
[341664b255a14d02a064e345af4906fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/60777cfad0004ff89f9d687ee2b48864.png
[c099aa4e191f4f948c8e10fd2846b5f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/02371bbc7ff4447ebd4d25bd57740540.png
[0a830109ede04570af82f32a8de047c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a3062fb4f691451e8eb90ba353fbd0b1.png
[581997abad95451fb78b2946f6a7bd17.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e7f8638e96b048ea8d4b4a9f1693487f.png
[f8aacf4a62d8432bb6673b39a0c5d8c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/bc4652106fad42438515aca479475e05.png
[9d80560669ad4b25913bfe8aef2e5f67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d026567bd8f2453daa4e872b40484cc7.png
[42328680c0cd40dcaa820f7fc9fe070f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/31152fc497174f28b6e61ea54df5ec8d.png
[2e9269e8d8b94150a2d19eb3caf4c8d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d7087d1611da474193c00686470aa7ca.png
[111796a05e584c23bb42fa7b7cc10fdd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a8ef5c2b59154791a639f4902c9349ce.png
[dd62b5f18a3c4d3ebc6c500a90942527.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/4731cbf2226844669fa3075d1204ea54.png
[0d06639730294c33974e075248192a92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/bf60597959f24ec19b4c43ec4b89560d.png
[e92ab86eb97d449cb251c6c10494ffe6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8bd0d71c69c84b2f87d0f63ab89abc96.png
[37d27ab25dd44cd48b0cb20716a767c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7446361b46ad4c43ae64aa155e8e576f.png
[29e7a0be02134ef4aaf1e07a873c44e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6c89646de8664152ba0ff93b962dd22d.png
[a0c6acfcc3dc4db49fd07e16560a30d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/05dc78f99404416fbe9e6b436814d8f5.png
[d55ae011846f45aab08bb066bd406798.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/58d890ac263e4cc093045facbb81d8ff.png
[Link 2]: https://blog.csdn.net/qq_74310471/category_12166401.html?spm=1001.2014.3001.5482
[Link 3]: https://blog.csdn.net/qq_74310471/category_12144452.html?spm=1001.2014.3001.5482
[Link 4]: https://blog.csdn.net/qq_74310471/category_12166402.html
[55270e2552774a17a711aa978da84193.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8abbd36940a344f8b4c3bd7bfc36c979.gif