C语言文件操作：从入门到精通

前言

今天学习的是C语言的文件操作，在开始学习之前我们先了解一下什么是文件

为什么使用文件

  我们前面学习结构体时，写通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
  我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

什么是文件

磁盘上面的是文件

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

程序文件

包括源程序文件（后缀.c)

目标文件（Windows环境后缀为.obj）

可执行程序（Windows环境后缀为.exe）

数据文件

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

这次我们讲解的是数据文件

在以前我们大部分输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上

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

文件名

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

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

例如：C:\code\test.txt

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

文件的打开和关闭

在了解文件的打开和关闭之前，我们先了解一下文件指针

文件指针

缓存文件系统中，关键的概念是是"文件类型指针"，简称文件指针

每个被使用的文件都会在内存中开辟一个相应的文件信息区，用来存放文件的相关信息（比如文件的名字，文件的状态及文件当前的位置等）

这些信息是保存在一个结构体变量中的

该结构体变量是由系统声明的，取名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指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

比如：

文件的打开和关闭

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

这俩点非常的重要，在后面的所有涉及文件相关操作都会用到！

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

（这里的意思就是只要你打开了一个文件，如果打开成功了，那么它就会返回一个FILE*类型的地址，那么你要创建的一个该类型的指针去接收它，后面你就可以通过你创建的这个指针来维护这个文件内容）
ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件

//打开文件
FILE * fopen ( const char * filename, const char * mode );
//关闭文件
int fclose ( FILE * stream );

//打开文件

返还类型：

• FILE*类型的指针(成功打开文件)
• NULL（文件打开失败）

filename：文件名（要带上后缀）

mode：文件的使用方式（不懂没事，后面会有一张图来说明的）

//关闭文件

返还类型 ：

• 0（关闭成功）
• EOF（-1）（关闭失败）

stream:你用来接受fopen函数的FILE*指针变量名

这里提醒一下在使用fopen函数的时候一定要判断一下它的返回值，

用fclose函数关闭文件的时候，一定要将原来接受文件指针的变量置为NULL

比如：

int main()
{
    //打开文件
    FILE* pf = fopen("data.txt","r");
    if(pf == NULL)
    {
        perror("fopen");//这是一个打印错误信息的函数
        return 1;
    }
    //关闭文件
    fclose(pf);
    pf == NULL;
    return 0;
}

接下来就讲一下文件的打开方式，想必大家已经看到我了我上面fopen函数中用的"r"了，先看图：

文件的使用方式	含义	如果指定文件不存在
"r"（只读）	为了输入数据，打开一个已经存在的文本文件	出错
"w"（只写）	为了输出数据，打开一个文本文件	建立一个新的文件
"a"（追加）	向文本文件尾添加数据	建立一个新的文件
"rb"（只读）	为了输入数据，打开一个二进制文件	出错
"wb"（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
"ab"（追加）	向一个二进制文件尾添加数据	建立一个新的文件
"r+"（读写）	为了读和写，打开一个文本文件	出错
"w+"（读写）	为了读和写，打开一个文本文件	建立一个新的文件
"a+"（读写）	打开一个文件，在文件尾进行读写	建立一个新的文件
"rb+"（读写）	为了读和写打开一个二进制文件	出错
"wb+"（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
"ab +"（读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件

这里说一下一个小细节，"w"只写的话他会在写入前清空文件里的内容

示例代码：

/* fopen fclose example */
#include <stdio.h>
int main ()
{
 FILE * pFile;
 //打开文件
 pFile = fopen ("myfile.txt","w");
 //文件操作
 if (pFile!=NULL)
{
   fputs ("fopen example",pFile);
   //关闭文件
   fclose (pFile);
}
 return 0;
}

文件的顺序读写

顺序读写就是按数据原本从前到后的顺序进行读取或者写入

顺序读取函数介绍

功能	函数名	适用于
字符输入函数	fgetc	所有输入流
字符输出函数	fputc	所有输出流
文本行输入函数	fgets	所有输入流
文本输出行函数	fputs	所有输出流
格式化输入函数	fscanf	所有输入流
格式化输出函数	fprintf	所有输入流
二进制输入	fread	文件
二进制输出	fwrite	文件

我知道你看到这里看到有许多疑问，流是什么东西？输入输出的走向到底是怎么样的？但是我们先把疑问放在心里，我先带大家了解一下上面这些函数，它们的使用方法、返回值、参数的具体情况

字符输入/输出函数

字符输入函数：

                        int fgetc(FILE* stream)

功能:从stream指向的文件中，读取当前位置的1个字符，并将文件指针向后移动一位

返回值：

• 成功：返回读取到的字符的ASCII码值
• 失败/读取到文件尾：返回EOF（需要使用feof()来判断是否为文件尾导致的的输入失败）

参数：stream就是你代开文件时，用来承接fopen函数返回值的变量名

关键用法：不能再读取前判断，需要先调用fgetc/fread等读取函数，再用feof判断是否因为到文件尾导致的读取终止

字符输出函数：

                        int fputc(int ch, FILE* stream)

功能：将ch对应的字符（忽略高低位，反取低8位），写入stream指向的文件，文件指针向后移动1位

返回值：

• 成功：返回写入字符的ASCII码值（ch的低八位）
• 失败：返回EOF

参数：是要写入的字符（ASCII码）（也可以是'a'这种写法），stream是文件句柄

接下来看代码的使用过程：

fgetc

这里的代码和注释看不清的话，没关系下面我把代码和注释拿出来了，主要是看一下文档内容和文档位置、打印结果的联系

#include<stdio.h>

int main()
{
	int ch = 0;//储存fgetc的返回值
	//打开文件
	FILE* pf = fopen("data.txt", "r");
	//判断是否正常打开文件
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写入文件
	//因为你每调用一次fgetc函数，都会使data.txt内的指针往后移动一位
    //所有你要用一个int类型的变量去接收fgetc的返回值
	//因为while判断时调用一次，但是未打印，文件指针移动到后一位（偏移量+1）
	//printf函数打印时调用了fgetc函数，此时打印的是偏移量+2的值
	//所有反复循环打印的就都是偶数位的字符了
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c", ch);
	}
	//while循环结束以后，用feof来判断循环是到文件尾结束的，还是异常结束的
	if (feof(pf))
	{
		printf("\n文件指针已到文件尾！\n");
	}
	else
	{
		printf("\n文件指针未到文件尾！\n");
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这里要注意一下啊，如果你要打开的文档和你的.c代码文件是同一个目录的话，那么就可以直接输入文档的名字加后缀，具体的请看这个表格：

路径符号	作用（相对路径）	适用场景	操作系统差异
./	表示当前目录	访问当前程序运行目录下的文件	Windows/Linux/macOS 均支持
../	表示上一级目录	访问当前目录的父目录下的文件	同上
/	1. 绝对路径根目录（Linux/macOS）2. 路径分隔符（Windows 中是 \）	1. 访问系统根目录下的文件2. Windows 中需转义为 \\	Linux/macOS 用 / 分隔；Windows 用 \（代码中需写 \\）

代码中涉及到的feof函数，这里我也简单的提一下

int feof(FILE* stream)

返回值：

1. 返回一个非零值（通常是 1）：

   • 这表示文件结束标志（End-of-File indicator）已经被设置。
   • 意味着：上一次对该文件流进行的读取操作（如 fgetc, fgets, fread 等）已经尝试读取并越过了文件的末尾。

2. 返回 0：

   • 这表示文件结束标志没有被设置。
   • 意味着：上一次读取操作成功读取了数据，或者文件流刚刚被打开，还没有进行任何读取操作。

关键点

• feof 的返回值只告诉我们 “上一次读取的状态”，它无法预测下一次读取是否会成功。
• 它不能替代对读取函数返回值的检查（例如，检查 fgetc 的返回值是否为 EOF）。
• 它通常用于在循环结束后，判断循环退出的具体原因：是正常读完了文件，还是因为发生了其他错误。

fputc

先看代码使用：

这里我们打开data.txt的方式是只写，所以文档里面的东西会清空，但是当我们运行完代码以后，打开文档可以看到的是里面存放了26个字母，而代码中我们只用了一个for循环语句，我们知道fputc的第一个参数是int类型的，虽然我们传过去的是字符，但是最后还是会转换成ASCII值的形式，我们在这个基础上对'a'进行加i操作其实是可以的

#include<stdio.h>

int main()
{
	//打开文件
	FILE* pf = fopen("data.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//读取文件
	for (int i = 0; i < 26; i++)
	{
		fputc('a' + i, pf);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

文本行输入/输出函数

文本行输入函数

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

功能：从文件读取字符到str（str可以是直接创建的数组），最多读取num-1个字符（保留1位存'\0'），遇到'\n'或文件尾停止（'\n'会保留在字符串中）

返回值：

• 成功：返回str指向的地址
• 失败/文件尾：返回NULL（需结合feof来判断）

参数：

1. str： 存储读取到的字符的字符数组（接受缓冲区）
2. num： 最大的读取字符数（实际读取数要-1）（核心！可以避免缓冲区溢出！）
3. stream：文件句柄

文本行读取函数

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

功能：将字符串str(不含末尾的'\0')完整写入文件，不会自动添加换行符'\n'

返回值：

• 成功：返回非负值
• 失败：返回EOF

参数：

1. str：要写入的字符串（如"hello"、字符串数组名）
2.  stream：文件句柄

fgets

这里看代码实操：

#include<stdio.h>

int main()
{
    //这里只是为了测试所以用了初始化为1的数组来作为fgets第一个参数
	char ch[7] = {1,1,1,1,1,1,1};
	//打开文件
	FILE* pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//读取文件
	fgets(ch, 7, pf);//从pf里取5-1个字符放在ch里面
	printf("%s", ch);
	printf("****");
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

在这里我们可以看到确实只读取了4个字符，在ch第五个字符的位置处放了'\0'

我在文档里准备好了数据"1234\n5678"，而代码中并没有手动添加'\n'，但是打印结果确实自动换行的，说明fgets确实遇到'\n‘就会停止读取，并且保留'\n’

fputs

先看代码实操：

#include<stdio.h>

int main()
{
	//打开文件
	FILE* pf = fopen("data.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写入文件
	if (fputs("hello", pf) != EOF)
	{
		printf("写入成功！\n");
	}
	else
	{
		printf("写入失败！\n");
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

如果连续使用fputs对同一个文件句柄写入的话，确实并不会自动添加'\n'

格式化输入/输出函数

格式化输入函数

int fscanf(FILE* stream, const char* format, ...)

核心参数：

1. stream：文件句柄
2. format：格式控制字符串（"%d %s %f"之类的）
3. 可变参数(...)：存储读取结果的变量地址（&num、str（字符数组）、&ch之类的）

功能：从stream指向的文件中，按format指定的格式来读取数据，存入后续变量（需传变量地址）

返回值的三种情况：

1. 返回成功匹配并赋值的输入项数量。

   • 这是最常见的情况。例如，fscanf("%d %s", &num, str) 如果成功读取了一个整数和一个字符串，就会返回 2。

2. 返回 0。

   • 当 fscanf 尝试读取数据，但数据的类型不匹配时，会返回 0。
   • 例如，你用 %d 格式符去读取一个字母 'a'，fscanf 发现类型不对，无法完成赋值操作，于是返回 0。
   • 注意：在这种情况下，文件指针不会移动，那个不匹配的字符会被留在输入缓冲区中，等待下一次读取。

3. 返回 EOF (End Of File)。

   • 当 fscanf 在读取过程中遇到了文件末尾（没有更多数据可读取），或者发生了读取错误（如磁盘故障、权限问题等）时，会返回 EOF。
   • EOF 是一个在 <stdio.h> 中定义的宏，通常它的值是 -1。

关键：fscanf不像fgetc、fgets一样有明确的一次读取的字符数，fscanf一次读取的字符数是不固定的，取决于格式符和文件内容，fscanf是“按格式匹配数据项”，而非固定的字符数

比如：

格式"%d"：读取整数时，会跳过空格和换行符，读取所有连续的数字

格式"%d"：如果遇到的第一个字符是非空字符，而不是整型，则会读取失败返回0

格式"%d"：如果只有一个格式"%d",那么fscanf读取一个整型返回1，就不会再往后在读了，除非再次调用

格式化输出函数

int fprintf(FILE* stream, const char* format,...)

核心参数：

1. stream：文件句柄
2. format： 格式控制符串（"%d %s %f"之类的）
3. 可变参数（...）：要写入具体的数据（如"张三"，20，或者变量名）

功能：按format指定的格式，将后续数据写入stream指定的文件

返回值：

1. 返回值 > 0：表示成功写入了指定数量的字符。

   • 例如，fprintf(pf, "Hello, %s!", "World") 会返回 13，因为 "Hello, World!" 这个字符串加上末尾自动添加的 \0 结束符，总共是 13 个字符（注：实际返回的是打印的字符数，不包括 \0，"Hello, World!" 实际是 13 个可见字符）。

2. 返回值 = 0：表示没有字符被写入。

   • 这通常发生在格式化字符串中没有任何有效内容需要写入，或者所有参数都被忽略的情况下（这种情况比较少见）。

3. 返回值 = EOF：表示发生了写入错误。

   • EOF 是一个宏，值为 -1。
   • 常见原因：
     • 磁盘已满，无法写入。
     • 对只读文件进行写入操作。
     • 网络连接中断（如果写入的是网络流）。
     • 设备故障。

看代码实操：

#include<stdio.h>

struct pers
{
	char name[10];
	int age;
	char sex[5];
	char home[10];
};
int main()
{
	struct pers per2 = { "张三",34,"男","上海" };
	//打开文件
	FILE* pf = fopen("data.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写入文件
	fprintf(pf, "%2s %2d %1s %2s", per2.name, per2.age, per2.sex, per2.home);
	
	//关闭文件
	fclose(pf);
	pf = NULL;
	//打开文件
	struct pers per1 = {"lisi",45,"nv","beijing"};
	pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen2");
		return 1;
	}
	//读取文件
	fscanf(pf, "%4s %2d %2s %4s", per1.name, &(per1.age), per1.sex, per1.home);
	printf("%s %d %s %s", per1.name, per1.age, per1.sex, per1.home);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

以上面这个代码为基础我讲几个细节点：

• 如果你想直接在文件中输入好数据，然后用fscanf函数来写入的话，一定要文件的字符编码和你的编译器的是一致的，不如读取出来的内容打印在屏幕上会是乱码
• 用fprintf函数来读取数据的时候，一定要在格式字符串加上限制读取的字符数，不然容易造成内存泄露
• 如果输入的数据是中文，那么在限制字符数的时候一定要x2，因为一个中文占俩个字节
• 读取的数据放入文件中，每个数据之间必须要用空格或者换行符隔开

二进制输入输出

二进制输入

size_t fread(void* Per, size_t size, size_t number, FILE* stream)

关键参数：

1. Per：接收数据的缓冲区（如数组、结构体指针）
2. size：单个数据块的字节数（如sizeof（int））
3. number：要读取的数据块个数
4. stream：文件句柄

返回值：

• 成功：读取到的数据块的个数（不是字节）
• 失败：返回小于number的数，可能是到了文件尾或是读取失败

核心作用：从文件读取number个“大小为size字节”的数据块，存入Per指向的缓冲区

二进制输出

size_t fwrite(const void* Per, size_t size, size_t number, FILE* stream)

关键参数：

1. Per：接收数据的缓冲区（如数组、结构体指针）
2. size：单个数据块的字节数（如sizeof（int））
3. number：要读取的数据块个数
4. stream：文件句柄

返回值：

• 成功：读取到的数据块的个数（不是字节）
• 失败：返回小于number的数，可能是到了文件尾或是读取失败

核心作用：

将Per缓冲区中number个“大小为size个字节”的数据块，原样写入文件

看代码实操：

#include<stdio.h>

struct pers
{
	char name[10];
	int age;
	char sex[5];
	char home[10];
};
int main()
{
	struct pers per = { "zhangsan",67,"nan","guangzhou" };
	//打开文件
	FILE* pf = fopen("data.txt", "wb");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写入文件
	fwrite(&per, sizeof(per), 1, pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	
	//打开文件
	struct pers per1;
	pf = fopen("data.txt", "rb");
	if (NULL == pf)
	{
		perror("fopen");
		return 2;
	}
	//读取文件
	fread(&per1, sizeof(per1), 1, pf);
	printf("%s %d %s %s", per1.name, per1.age, per1.sex, per1.home);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

因为篇幅受限，所有放不了图片了，我这边给你看复制过来看二进制显示是什么样子的

zhangsan  烫C   nan  guangzhou ?

这就是在文本中的二进制显示，会显示成乱码的形式

代码结果：

zhangsan 67 nan guangzhou

然后这里再讲几个很关键的要注意的点

1. 二进制的输入和输出都只针对二进制数据，不能用二进制函数的读取文本格式的数据
2. 二进制函数只考虑字节大小，不考虑字符数，所有，像我刚刚代码里面的那个结构体，我直需要把我结构体变量的地址传过去，然后把结构体的变量大小字节传过去，如果我只拷贝一个结构体，那么number那一参数我只要输入1即可，

文件的随机读写

ftell()

long ftell(FILE* stream)

获取文件指针“下标”的核心函数，能返回当前文件指针相对去文件开头的字节偏移量，原型为long

返回值：

• 成功：返回偏移量
• 失败：返回-1

fseek()

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

虽不直接获取偏移量，但可移动文件指针，常和ftell()搭配实现文件大小计算功能

参数：

stream: 文件句柄

offset：偏移量

origin：起始基准

     ||

     V

SEEK_SET 以文件开头为基准（默认）

SEEK_CUR 以当前文件指针位置为基准

SEEK_END 以文件末尾为基准

接下来看代码实现：

#include<stdio.h>

int main()
{
	//打开文件
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读取文件
	long p = ftell(pf);
	printf("pf初始的偏移量%d\n", p);
	//用fseek来使文件指针指向距离起偏移量为2的位置
	fseek(pf, 2, SEEK_SET);
	p = ftell(pf);
	printf("fseek后的偏移量%d\n", p);
	int ch = getc(pf);
	printf("%c", ch);
	//关闭文件
	fclose(pf);
	pf = NULL;
	

	return 0;
}

正常情况下，应该是输出'a'的，但是因为fseek()函数的使用，使文件指针移到了偏移量为2的位置

如果fseek参数填的是SEEK_END的话，那么你可以输入一个负数来使其可以打印前面的数

流的介绍

在 C 语言中，流（Stream） 是一个抽象概念，用于统一描述程序与外部设备（如键盘、显示器、文件、网络等）之间的数据传输过程。它屏蔽了不同设备的底层差异，让程序员可以用相同的一套标准库函数（如 printf、scanf、fread、fwrite 等）操作所有外部数据，无需关心数据是来自键盘、写入文件还是通过网络传输。

一、流的核心本质：“数据管道”

可以把流理解为程序与外部设备之间的 “数据管道”：

• 数据从外部设备（如文件、键盘）流入程序 → 输入流（Input Stream）；
• 数据从程序流出到外部设备（如显示器、文件） → 输出流（Output Stream）；
• 有些设备支持双向传输（如文件），对应 “输入输出流（I/O Stream）”。

流的核心价值是 “设备无关性”：无论底层是键盘（字符设备）、硬盘文件（块设备）还是网络，C 语言都将其封装为 “流”，操作接口完全一致。例如：

三、C 语言的标准流（预定义流）

C 程序启动时，系统会自动创建 3 个标准流（无需手动打开，可直接使用），它们都属于文本流：

1. 标准输入流stdin
2. 标准输出流stdout
3. 标准错误流stderr

• 用 fprintf 既可以向显示器（标准输出流）输出，也可以向文件流输出；
• 用 fscanf 既可以从键盘（标准输入流）读取，也可以从文件流读取。

• 二、流的分类

  C 语言中的流主要分为两类：文本流（Text Stream） 和 二进制流（Binary Stream），二者的核心区别是数据的存储和解析方式。

  特性	文本流（Text Stream）	二进制流（Binary Stream）
  数据形式	以字符（ASCII 或宽字符） 为单位存储，本质是文本字符串	以字节（Byte） 为单位存储，是数据的原始二进制形式
  换行处理	会自动进行换行符转换（如 Windows 下 \n 转为 \r\n，读取时反向转换）	不做任何转换，数据 “原样传输”（写入什么，读出就是什么）
  适用场景	存储文本数据（如.txt 文件、控制台输入输出）	存储非文本数据（如图片、视频、可执行文件、结构体数据）
  操作示例	printf、scanf、fgets、fputs	fread、fwrite、fgetc（直接读字节）

  关键注意：

• 文本流的换行转换是 “透明的”（由系统自动处理），程序员无需关心底层系统的换行符差异；
• 二进制流的 “原样传输” 保证了数据的完整性，例如存储结构体时，不会因字符转换破坏数据。

流名称	含义	对应的设备	标准库文件指针	常用操作函数
标准输入流	程序从外部读取数据	键盘（默认）	stdin	scanf、fscanf、getchar
标准输出流	程序向外部输出数据	显示器（默认）	stdout	printf、fprintf、putchar
标准错误流	程序输出错误信息	显示器（默认）	stderr	fprintf(stderr, "...")

#include <stdio.h>

int main() {
    int num;
    // 操作标准输入流 stdin：从键盘读数据
    printf("请输入一个数字：");  // stdout 输出提示
    scanf("%d", &num);           // stdin 读取输入

    // 操作标准输出流 stdout：向显示器输出正常信息
    printf("你输入的数字是：%d\n", num);

    // 操作标准错误流 stderr：输出错误信息（即使重定向 stdout，stderr 仍会显示在屏幕）
    fprintf(stderr, "这是一条错误提示（不会被重定向）\n");

    return 0;
}

标准错误流的特殊用途：

stderr 与 stdout 的区别是无缓冲（stdout 是行缓冲），且默认不随 stdout 重定向（例如将程序输出重定向到文件时，错误信息仍会显示在屏幕上），适合输出紧急错误。

四、文件流（自定义流）

除了标准流，程序还可以手动打开外部文件，创建文件流（可是文本流或二进制流），通过文件指针（FILE* 类型）操作。

核心操作流程：

1. 打开文件：用 fopen 函数创建文件流，返回 FILE* 指针（失败返回 NULL）；
2. 操作流：用标准库函数读写数据（文本流用 fscanf/fprintf，二进制流用 fread/fwrite）；
3. 关闭流：用 fclose 函数关闭流（必须关闭，否则可能导致数据丢失或资源泄露）。

示例 1：操作文本文件流

#include <stdio.h>

int main() {
    // 打开文本文件（"w" 表示写入，文本流）
    FILE* fp = fopen("test.txt", "w");
    if (fp == NULL) {  // 检查打开失败
        perror("fopen failed");
        return 1;
    }

    // 向文本文件流写入数据（类似 printf，但目标是文件）
    fprintf(fp, "Hello, 文本流！\n");
    fprintf(fp, "这是第二行文本\n");

    // 关闭流（必须执行，否则数据可能未写入文件）
    fclose(fp);

    // 再次打开文件，读取数据
    fp = fopen("test.txt", "r");
    if (fp == NULL) {
        perror("fopen failed");
        return 1;
    }

    char buf[100];
    // 从文本文件流读取数据（类似 scanf，但来源是文件）
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        printf("读取到：%s", buf);  // 输出到 stdout
    }

    fclose(fp);
    return 0;
}