1.什么是文件
1.1文件的概念
文件（File）是计算机中用于持久化存储数据的基本单位。它可以存储文本、图片、音频、程序代码等各种信息，并在程序运行结束后仍然保留数据。
1.2文件名
一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含三部分：文件路径+文件名主干+文件后缀
例如：C:\code\test.txt
为了方便起见，文件标识常被成为文件名
1.3程序文件和数据文件
文件按内容用途划分可以分为程序文件和数据文件。
| 程序文件 | 数据文件 |
|---|---|
| 使计算机执行特定任务 | 存储程序处理或生成的输入/输出数据 |
| 包含可执行代码或支持代码执行的资源 | 结构化或非结构化数据 |
| 示例：源代码文件（.c, .java）可执行文件（.exe, .out）库文件（.dll, .so） | 示例：配置文件（.ini, .json）数据库文件（.db, .sqlite）多媒体文件（.mp3, .jpg） |
本文讨论的是数据文件，在以前我们处理数据的输入输出都是以终端为对象的，即从键盘输入数据，运行结果显示到显示器上。其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
1.4二进制文件和文本文件
根据数据的存储方式和内容的可读性，文件还可以分成二进制文件和文本文件。
| 文本文件 | 二进制文件 |
|---|---|
| 以字符编码（如 ASCII、UTF-8、GBK 等）存储数据，每个字符对应特定的字节序列。 | 以原始字节流（Byte Stream）存储数据，直接对应计算机可识别的二进制格式，不依赖字符编码。 |
| 内容可直接用文本编辑器（如记事本、Notepad++）打开并查看，人类可理解。 | 内容无法用普通文本编辑器正确解析，直接查看会显示乱码，需用特定软件（如图片查看器、播放器、编译器）处理。 |
如有整数10000，如果以ASCII码的形式输出到磁盘，则在磁盘中占用5个字节（每个字符一个字节），而以二进制形式输出，则在磁盘上只占4个字节。
在vs2022上打开二进制文件：
2.文件的打开和关闭
2.1流和标准流
我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输⼊输出
操作各不相同，为了⽅便程序员对各种设备进⾏⽅便的操作，我们抽象出了流的概念，我们可以把流
想象成流淌着字符的河。
C程序针对⽂件、画⾯、键盘等的数据输⼊输出操作都是通过流操作的。
⼀般情况下，我们要想向流⾥写数据，或者从流中读取数据，都是要打开流，然后操作。
那为什么我们从键盘输⼊数据，向屏幕上输出数据，并没有打开流呢？
那是因为C语⾔程序在启动的时候，默认打开了3个流：
• stdin -标准输⼊流，在⼤多数的环境中从键盘输⼊，scanf函数就是从标准输⼊流中读取数据。
• stdout - 标准输出流，⼤多数的环境中输出⾄显⽰器界⾯，printf函数就是将信息输出到标准输出 流中。
• stderr -标准错误流，⼤多数环境中输出到显⽰器界⾯。
这是默认打开了这三个流，我们使⽤scanf、printf等函数就可以直接进⾏输⼊输出操作的。
stdin、stdout、stderr 三个流的类型是： FILE* ，通常称为⽂件指针。
C语⾔中，就是通过 FILE* 的⽂件指针来维护流的各种操作的。
2.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* pf;//文件指针变量
定义pf是⼀个指向FILE类型数据的指针变量。可以使pf指向某个⽂件的⽂件信息区（是⼀个结构体变
量）。通过该⽂件信息区中的信息就能够访问该⽂件。也就是说，通过⽂件指针变量能够间接找到与
它关联的⽂件。
2.3文件打开与关闭函数
⽂件在读写之前应该先打开⽂件，在使⽤结束之后应该关闭⽂件。
在编写程序的时候，在打开⽂件的同时，都会返回⼀个FILE*的指针变量指向该⽂件，也相当于建⽴了指针和⽂件的关系。
ANSI C 规定使⽤ fopen 函数来打开⽂件， fclose 来关闭⽂件。
//打开⽂件
FILE* fopen(const char* filename, const char* mode);
//关闭⽂件
int fclose(FILE* stream);
mode表⽰⽂件的打开模式，下⾯都是⽂件的打开模式：
示例代码：
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "w");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fputs("hello world", pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
3.文件的顺序读写
3.1 fgetc 和 fputc
fgetc 是 C 语言标准库中用于从文件流中读取单个字符的函数，其功能简单但在文件操作中非常实用。函数原型如下：
int fgetc(FILE *stream);
参数：
stream 是指向 FILE 类型的指针，表示要读取的文件流（可以是文件或标准输入 stdin）。
返回值：
成功读取时，返回读取到的字符（转换为 int 类型，范围为 0~255）。
到达文件末尾或发生错误时，返回 EOF（一个宏定义，通常为 -1）。
示例代码：
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "r");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
while ((ch = fgetc(pf)) != EOF)
{
printf("%c", ch);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
注意：返回值类型为 int 而非 char，原因是需要用 EOF（-1）表示错误或文件结束，而 char 类型无法表示负数。因此，必须用 int 类型接收返回值。
fputc 是 C 语言标准库中用于向文件流写入单个字符的函数，与 fgetc 功能对应，是文件操作中最基础的写入工具之一。函数原型如下：
int fputc(int c, FILE *stream);
参数：
c：要写入的字符（整数类型，通常为 char 类型转换而来，范围 0~255）。
stream：指向 FILE 类型的指针，表示目标文件流（可以是文件或标准输出 stdout）。
返回值：
成功写入时，返回写入的字符（转换为 int，即参数 c 的值）。
写入失败时，返回 EOF（宏定义，通常为 -1）。
示例代码：
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "w");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
const char* str = "yuecheng";
for (int i = 0; str[i] != '\0'; i++)
{
fputc(str[i], pf);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
3.2 fgets 和 fputs
fputs 是 C 语言标准库中用于向文件流写入字符串的函数，是文本文件操作的常用工具之一。它与 fputc（逐字符写入）不同，支持批量写入字符串，适用于高效处理文本数据。函数原型如下：
int fputs(const char *str, FILE *stream);
参数：
str：指向要写入的字符串（以 ‘\0’ 结尾的字符数组或指针）。
stream：指向目标文件流的指针（如文件指针或标准输出 stdout）。
返回值：
成功写入时，返回一个非负整数（具体值未指定，通常视为成功标志）。
写入失败时，返回 EOF（宏定义，值为 -1）。
示例代码：
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "w");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
const char* str1 = "yuecheng";
const char* str2 = "boke";
fputs(str1, pf);
fputs("\n", pf);//手动换行
fputs(str2, pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
fgets 是 C 语言标准库中用于从文件流（或标准输入）读取字符串的函数，是文本文件处理和用户输入的重要工具。其核心优势在于安全可控（可指定读取长度，避免缓冲区溢出），适用于逐行读取数据。函数原型如下：
char *fgets(char *str, int num, FILE *stream);
参数：
str：指向字符数组的指针，用于存储读取的字符串（需确保缓冲区足够大）。
num：读取的最大字符数（包括终止符 ‘\0’），即最多读取 num-1 个有效字符，末尾自动添加 ‘\0’。
stream：目标文件流（如文件指针 FILE* 或标准输入 stdin）。
返回值：
成功时，返回指向缓冲区 str 的指针（与输入参数相同）。
遇到文件结束或错误时，返回 NULL。
fgets详细介绍网页
示例代码：
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "r");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
char buff[500] = { 0 };
while (fgets(buff, sizeof(buff), pf))
{
printf("%s", buff);// 输出读取的行（含换行符）
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
3.3 fscanf和fprintf
fprintf 是 C 语言标准库中用于向文件流（或标准输出）写入格式化数据的核心函数，功能与 printf 类似，但目标是文件而非控制台。它支持将不同类型的数据（整数、浮点数、字符串等）按指定格式写入文件，是文本文件处理和日志记录的重要工具。函数原型如下：
int fprintf(FILE *stream, const char *format, ...);
参数：
stream：目标文件流指针（如文件指针 FILE* 或标准输出 stdout）。
format：格式化字符串（包含普通字符和格式说明符）。
…：可变参数列表（需与格式说明符一一对应）。
返回值：
成功时，返回实际写入的字符数（不包含终止符 ‘\0’）。
失败时，返回负数（具体值未指定，通常用 ferror(stream) 判断错误）。
fprintf详细介绍网页
示例代码：
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "w");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fprintf(pf, "%-10s %-15s %s\n", "ID", "Name", "Score");
fprintf(pf, "-------------------------------------------------\n");
fprintf(pf, "%-10d %-15s %6.2f\n", 1, "Bob", 85.5);
fprintf(pf, "%-10d %-15s %6.2f\n", 2, "Alice", 92.3);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
fscanf 是 C 语言标准库中用于从文件流（或标准输入）读取格式化数据的核心函数，功能与 scanf 类似，但目标是文件而非控制台。它支持按指定格式解析不同类型的数据（整数、浮点数、字符串等），是处理结构化文件（如配置文件、日志、表格数据）的重要工具。函数原型如下：
int fscanf(FILE *stream, const char *format, ...);
参数：
stream：目标文件流指针（如文件指针 FILE* 或标准输入 stdin）。
format：格式化字符串（包含格式说明符和普通字符）。
…：可变参数列表（需是指针，用于存储读取的数据）。
返回值：
成功时，返回成功匹配的参数个数（可能为 0，表示格式匹配但无数据读取）。
遇到文件结束或错误时，返回 EOF（宏定义，值为 -1）。
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "r");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
char ch1[10] = { 0 };
char ch2[10] = { 0 };
char ch3[10] = { 0 };
fscanf(pf, "%s %s %s\n", ch1, ch2, ch3);
printf("%s %s %s", ch1, ch2, ch3);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
4. fread 和 fwrite
fwrite 是 C 语言标准库中用于向文件流写入二进制数据块的函数，主要用于高效存储和读取结构化数据（如结构体、数组、二进制文件）。与文本文件操作函数（如 fprintf、fputs）不同，fwrite 直接按字节写入，不进行任何格式转换或字符编码处理，是处理二进制文件的核心工具。函数原型如下：
size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);
参数：
ptr：指向要写入的数据块的指针（可以是数组、结构体等）。
size：每个数据块的字节大小（如单个元素的大小，如 sizeof(int)）。
count：要写入的数据块数量（总字节数为 size × count）。
stream：目标文件流指针（需以 二进制模式 打开，如 wb、ab）。
返回值：
成功时，返回实际写入的数据块数量（类型为 size_t，通常是无符号整数）。
若返回值小于 count，可能是写入错误或文件空间不足，需通过 ferror(stream) 判断。
fwrite详细介绍网页
示例代码：
struct stu {
char name[20];
int ID;
int age;
};
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "wb");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
struct stu stu1 = { "zhangsan",20240523,18 };
//写文件
fwrite(&stu1, sizeof(stu1), 1, pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
fread 是 C 语言标准库中用于从文件流读取二进制数据块的函数，主要用于高效地从文件中恢复结构化数据（如结构体、数组、二进制文件中的数据）。与文本文件读取函数（如 fscanf、fgets）不同，fread 直接按字节读取，不进行任何格式解析或字符编码转换，是处理二进制文件的核心工具。函数原型如下：
size_t fread(void *ptr, size_t size, size_t count, FILE *stream);
参数：
ptr：接收数据的缓冲区指针（如结构体地址、数组名）。
size：单个数据块的字节大小（如 sizeof(int)、sizeof(自定义结构体)）。
count：期望读取的数据块数量（总读取字节数 = size × count）。
stream：目标文件流（必须以 二进制模式 打开，如 rb、ab+）。
返回值：实际读取的数据块数量（若小于 count，需通过 feof/ferror 判断是文件结束还是错误）。
fread详细介绍网页
示例代码：
struct stu {
char name[20];
int ID;
int age;
};
int main()
{
//打开文件
FILE* pf = fopen("test1.txt", "rb");
//如果打开失败，结束程序
if (pf == NULL)
{
perror("fopen");
return 1;
}
struct stu stu2 = { 0 };
//读文件
fread(&stu2, sizeof(stu2), 1, pf);
printf("%s %d %d", stu2.name, stu2.ID, stu2.age);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
4.文件的随机读写
1.fseek
根据⽂件指针的位置和偏移量来定位⽂件指针。函数原型如下：
int fseek ( FILE * stream, long int offset, int origin );
函数参数
stream：这是一个指向 FILE 对象的指针，该对象标识了要操作的文件流。在使用 fseek 之前，需要使用 fopen 函数打开文件以获取对应的 FILE 指针。
offset：表示相对于 origin 指定的起始位置的偏移量，单位是字节。这个值可以是正数（表示向文件末尾方向移动）、负数（表示向文件开头方向移动）或者零。
origin：指定了偏移量的起始位置，它是一个整数常量，有以下三种取值：
SEEK_SET：表示从文件的开头开始计算偏移量。
SEEK_CUR：表示从文件指针的当前位置开始计算偏移量。
SEEK_END：表示从文件的末尾开始计算偏移量。
返回值
若函数调用成功，fseek 会返回 0。
若调用失败，则返回一个非零值，同时会设置 errno 来指示具体的错误类型。
fseek详细介绍网页
示例代码：
int main ()
{
FILE * pFile;
pFile = fopen ( "example.txt" , "wb" );
fputs ( "This is an apple." , pFile );
fseek ( pFile , 9 , SEEK_SET );
fputs ( " sam" , pFile );
fclose ( pFile );
return 0;
}
2.ftell
返回⽂件指针相对于起始位置的偏移量,函数原型如下：
long int ftell ( FILE * stream );
函数参数
stream：这是一个指向 FILE 对象的指针，该对象标识了要操作的文件流。在使用 ftell 之前，需要使用 fopen 函数打开文件以获取对应的 FILE 指针。
返回值
若函数调用成功，ftell 会返回当前文件指针相对于文件开头的偏移量，单位是字节，其类型为 long int。
若调用失败，它会返回 -1L，同时会设置 errno 来指示具体的错误类型。
ftell详细介绍网页
示例代码：
int main()
{
FILE* pFile;
long size;
pFile = fopen("myfile.txt", "rb");//文件内存有A~B26个字母
if (pFile == NULL)
perror("Error opening file");
else
{
fseek(pFile, 0, SEEK_END); // non-portable
size = ftell(pFile);
fclose(pFile);
printf("Size of myfile.txt: %ld bytes.\n", size);
}
return 0;
}
3.rewind
让⽂件指针的位置回到⽂件的起始位置,函数原型如下：
void rewind ( FILE * stream );
函数参数
stream：指向 FILE 对象的指针，该对象代表了要操作的文件流。在调用 rewind 之前，需要使用 fopen 函数打开文件以获取对应的 FILE 指针。
功能描述
rewind 函数会将文件指针移动到文件的起始位置，并且会清除文件流的错误指示器和文件结束指示器。这意味着在调用 rewind 之后，后续的文件操作将从文件开头开始，同时之前可能出现的错误状态也会被重置。
返回值
rewind 函数没有返回值（返回类型为 void）。
int main()
{
int n;
FILE* pFile;
char buffer[27];
pFile = fopen("myfile.txt", "w+");
for (n = 'A'; n <= 'Z'; n++)
fputc(n, pFile);
rewind(pFile);//将文件指针的位置返回到A
fread(buffer, 1, 26, pFile);//从头读取
fclose(pFile);
buffer[26] = '\0';
printf(buffer);
return 0;
}
5.feof和ferror
feof 的作⽤是：当⽂件读取结束的时候，判断是读取结束的原因是否是：遇到⽂件尾结束。
牢记：在⽂件读取过程中，不能⽤feof函数的返回值直接来判断⽂件的是否结束。
函数原型如下：
int feof(FILE *stream);
返回值
若文件流已到达文件末尾，feof 函数返回一个非零值（通常为 1）。
若未到达文件末尾，则返回 0。
ferror 函数用于检测文件流是否发生了错误。其原型如下：
int ferror(FILE *stream);
返回值
若文件流发生了错误，ferror 函数返回一个非零值（通常为 1）。
若未发生错误，则返回 0。
⽂本⽂件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
例如：
• fgetc 判断是否为EOF .
• fgets 判断返回值是否为 NULL .
2. ⼆进制⽂件的读取结束判断，判断返回值是否⼩于实际要读的个数。
例如：
• fread判断返回值是否⼩于实际要读的个数。
文本文件示例：
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);
}
二进制文件示例：
enum { SIZE = 5 };
int main()
{
double a[SIZE] = { 1.,2.,3.,4.,5. };
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 { // error handling
if (feof(fp))
printf("Error reading test.bin: unexpected end of file\n");
else if (ferror(fp)) {
perror("Error reading test.bin");
}
}
fclose(fp);
}
6.文件缓冲区
ANSIC 标准采⽤“缓冲⽂件系统” 处理的数据⽂件的，所谓缓冲⽂件系统是指系统⾃动地在内存中为程序中每⼀个正在使⽤的⽂件开辟⼀块“⽂件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才⼀起送到磁盘上。如果从磁盘向计算机读⼊数据，则从磁盘⽂件中读取数据输⼊到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的⼤⼩根据C编译系统决定。
int main()
{
FILE* pf = fopen("test.txt", "w");
fputs("abcdef", pf);//先将代码放在输出缓冲区
printf("睡眠10秒-已经写数据了，打开test.txt⽂件，发现⽂件没有内容\n");
Sleep(10000);
printf("刷新缓冲区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到⽂件（磁盘）
printf("再睡眠10秒-此时，再次打开test.txt⽂件，⽂件有内容了\n");
Sleep(10000);
fclose(pf);
//注：fclose在关闭⽂件的时候，也会刷新缓冲区
pf = NULL;
return 0;
}
这⾥可以得出⼀个结论：
因为有缓冲区的存在，C语⾔在操作⽂件的时候，需要做刷新缓冲区或者在⽂件操作结束的时候关闭⽂件。
如果不做，可能导致读写⽂件的问题。
扫一扫
1138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
