文章目录
1.为什么使用文件？
如果没有文件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运行程序，是看不到上次程序的数据的，如果要将数据进行持久化的保存，我们可以使用文件。
2.什么是文件？
磁盘（硬盘）上的文件是文件。
但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
2.1 程序⽂件
程序文件包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
2.2 数据⽂件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。
本章讨论的是数据文件。
在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
2.3 ⽂件名
一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：
- 文件路径
- 文件名主干
- 文件后缀
例如： c:\code\test.txt
为了方便起见，文件标识常被称为文件名。
3.二进制文件和文本文件？
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
数据在内存中以二进制的形式存储，如果不加转换的输出到外存的文件中，就是二进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在文件中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节。
我们先创建一个文件：只创建，什么都不写
测试代码：
#include <stdio.h>
int main()
{
int a = 10000;
FILE* pf = fopen("test.txt", "wb");//以二进制写的方式打开文件test.txt
fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
fclose(pf);
pf = NULL;
return 0;
}
程序运行完之后，打开文件，发现出现这个东西：
这个是因为它以二进制形式存储的原因。
我们可以证明一下：
发现文件里面放了10 27 00 00
因为这个数据是在内存中存放的，所以是以小端字节序存放的。
10000的二进制这么转化：
4.文件的打开和关闭
4.1 流和标准流
4.1.1 流
我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输入输出操作各不相同，为了方便程序员对各种设备进行方便的操作，我们抽象出了流的概念，我们可以把流想象成流淌着字符的河。
C程序针对文件、画面、键盘等的数据输入输出操作都是通过流操作的。
一般情况下，我们要想向流里写数据，或者从流中读取数据，都是要打开流，然后操作。
4.1.2 标准流
那为什么我们从键盘输入数据，向屏幕上输出数据，并没有打开流呢？
那是因为C语言程序在启动的时候，默认打开了
3个流：
stdin- 标准输入流，在大多数的环境中从键盘输入，scanf函数就是从标准输入流中读取数据。
stdout- 标准输出流，大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。
stderr- 标准错误流，大多数环境中输出到显示器界面。
这是默认打开了这三个流，我们使用scanf、printf等函数就可以直接进行输入输出操作的。
stdin、stdout、stderr 三个流的类型是： FILE * ，通常称为文件指针。
C语言中，就是通过 FILE* 的文件指针来维护流的各种操作的。
4.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指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够间接找到与它关联的文件。
比如：
4.3 ⽂件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。
ANSIC 规定使用 fopen 函数来打开文件， fclose 来关闭文件。
//打开文件
FILE * fopen ( const char * filename, const char * mode );
//关闭文件
int fclose ( FILE * stream );
mode表示文件的打开模式，下面都是文件的打开模式：
| 文件使用方式 | 含义 | 如果指定文件不存在 |
|---|---|---|
| “r”（只读） | 为了输入数据，打开一个已经存在的文本文件 | 出错 |
| “w”（只写） | 为了输出数据，打开一个文本文件 | 建立一个新的文件 |
| “a”（追加） | 向文本文件尾添加数据 | 建立一个新的文件 |
| “rb”（只读） | 为了输入数据，打开一个二进制文件 | 出错 |
| “wb”（只写） | 为了输出数据，打开一个二进制文件 | 建立一个新的文件 |
| “ab”（追加） | 向一个二进制文件尾添加数据 | 建立一个新的文件 |
| “r+”（读写） | 为了读和写，打开一个文本文件 | 出错 |
| “w+”（读写） | 为了读和写，建议一个新的文件 | 建立一个新的文件 |
| “a+”（读写） | 打开一个文件，在文件尾进行读写 | 建立一个新的文件 |
| “rb+”（读写） | 为了读和写打开一个二进制文件 | 出错 |
| “wb+”（读写） | 为了读和写，新建一个新的二进制文件 | 建立一个新的文件 |
| “ab+”（读写） | 打开一个二进制文件，在文件尾进行读和写 | 建立一个新的文件 |
我们来试试：
#include <stdio.h>
int main()
{
//1.打开文件
//打开成功的话，返回的是有效的指针
//如果打开失败，则返回空指针NULL
FILE* pf = fopen("data.txt","w");
if (pf == NULL) {
perror("fopen");
return 1;
}
return 0;
}
代码运行前：
代码运行前没有data.txt这个文件。
代码运行后：
我们发现代码运行后多了个data.txt文件。
如果我们运行代码前就有了呢?
#include <stdio.h>
int main()
{
//1.打开文件
//打开成功的话，返回的是有效的指针
//如果打开失败，则返回空指针NULL
FILE* pf = fopen("test.txt","w");
if (pf == NULL) {
perror("fopen");
return 1;
}
return 0;
}
我们先给test.txt文件里面写一点东西：
代码运行后：
直接变成0KB了，打开看 也发现是空的。
说明w的形式打开，原来就有文件了，那么就会把原来的东西清空。
要是没有文件就新建一个文件。
我们继续看fclose：
#include <stdio.h>
int main()
{
//1.打开文件
//打开成功的话，返回的是有效的指针
//如果打开失败，则返回空指针NULL
FILE* pf = fopen("test.txt","w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//写文件
//关闭文件
fclose(pf);
return 0;
}
我们调试一下：
我们发现，程序结束后pf地址没变，说明fclose()函数用完之后不会主动释为空，所以我们可以加一行代码 pf = NULL;
#include <stdio.h>
int main()
{
//1.打开文件
//打开成功的话，返回的是有效的指针
//如果打开失败，则返回空指针NULL
FILE* pf = fopen("test.txt","w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//写文件
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
当然，如果我要打开其他地方的test.txt文件要怎么写路径呢？
绝对路径：
FILE* pf = fopen("C:\\Users\\23878\\Desktop\\test.txt","w");
//这里用\\是为了防止转义字符
相对路径：
.表示当前路径
..表示上一级路径
FILE* pf = fopen(".\\..\\test.txt","w");
//当前路径的上一级路径
5.文件的顺序读写
5.1 顺序读写函数介绍
| 函数名 | 功能 | 适用于 |
|---|---|---|
| fgetc（读字符） | 字符输入函数 | 所有输入流 |
| fputc（写字符） | 字符输出函数 | 所有输出流 |
| fgets（读字符串） | 文本行输入函数 | 所有输入流 |
| fputs（写字符串） | 文本行输出函数 | 所有输出流 |
| fscanf | 格式化输入函数 | 所有输入流 |
| fprintf | 格式化输出函数 | 所有输出流 |
| fread | 二进制输入 | 所有输入流 |
| fwrite | 二进制输出 | 所有输出流 |
上面说的适用于所有输入流一般指适用于标准输入流和其他输入流（如文件输入流）；所有输出流一般指适用于标准输出流和其他输出流（如文件输出流）。
我们来试一试：
1.fputc
fputc
int fputc ( int character, FILE * stream );参数说明：
character：要写入的字符，该字符会被转换为unsigned char类型，然后写入文件流。
stream：指向要写入的文件流的指针。返回值：
如果成功，
fputc返回写入的字符。如果发生错误，
fputc返回EOF（End Of File，通常定义为-1）。
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//写文件
fputc('a', pf);
fputc('b', pf);
fputc('c', pf);
fputc('d', pf);
fputc('e', pf);
fputc('f', pf);
fputc('g', pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
程序运行完：
2.fgetc
fgetc
int fgetc ( FILE * stream );参数说明：
stream：指向要从中读取字符的文件流的指针。返回值：
如果成功，
fgetc返回读取的字符的ASCII码（一个 unsigned char 类型的值，被转换为 int 类型）。如果到达文件末尾或发生错误，
fgetc返回EOF。
EOF -- end of file文件的结束标志
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
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);
ch = fgetc(pf);
printf("%c\n", ch);
ch = fgetc(pf);
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
我们也可以写一个循环，让他打印所有的字符：
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//读文件
int ch = 0;
while ((ch = fgetc(pf)) != EOF) {
printf("%c\n", ch);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印:
#include <stdio.h>
int main()
{
int ch = fgetc(stdin);//从键盘（标准输入流）上读取
fputc(ch, stdout);//将字符输出（写）到屏幕（标准输出流）
return 0;
}
打印：
3.fputs
fputs
int fputs ( const char * str, FILE * stream );参数说明：
str：指向要写入的字符串的指针。
stream：指向要写入的文件流的指针。返回值：
如果成功，
fputs返回一个非负整数。如果发生错误，
fputs返回EOF（通常定义为-1）。
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.写文件
fputs("I am a student", pf);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
我们看一下路径里面：
打开发现里面确实有：I am a student
然后我们加一行代码：
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.写文件
fputs("I am a student", pf);
fputs("are you ok ?", pf);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
这里的are you ok ?会出现在第二行还是第一行呢？
因为我们没有添加换行符\n，想换行的话加上这个就可以了。
4.fgets
fgets
char * fgets ( char * str, int num, FILE * stream );参数说明：
str：指向用于存储读取数据的字符数组的指针。
num：指定要读取的最大字符数，包括字符串结束符\0。
stream：指向要读取的文件流的指针。返回值：
如果成功，
fgets返回指向str的指针。如果到达文件末尾或发生错误，
fgets返回NULL。
我们先在文件里面写上一些：
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
char arr[20] = "xxxxxxxxxxxx";
fgets(arr,5,pf);
printf("%s\n", arr);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
abcd
我们调试一下：
这里面确实读取了5个字符，但是第5个字符是\0，也就是说真正有效的读取是5。
我们把代码改一下，改成读取10个字符：
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
char arr[20] = "xxxxxxxxxxxx";
fgets(arr,10,pf);
printf("%s\n", arr);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
同时我们把txt文件里面的字符换行一下：
打印：
我们调试一下：
发现只读取了7个字符。
这是因为换行符使 fgets 停止读取，但它被函数视为有效字符，并包含在复制到 str 的字符串中。然后加上\0。
5.fprintf
fprintf
int fprintf ( FILE * stream, const char * format, ... );参数说明：
stream：指向要写入的文件流的指针。
format：一个字符串，包含格式说明符和普通字符。格式说明符用于指定如何格式化后续的参数。
...：可变参数列表，包含要写入的值，这些值将根据format字符串中的格式说明符进行格式化。返回值：
如果成功，
fprintf返回写入的字符数。如果发生错误，
fprintf返回一个负值。
printf
int printf ( const char * format, ... );参数说明：
format：一个字符串，包含普通文本和格式说明符。格式说明符用于指定如何格式化后续的参数。
...：可变参数列表，包含要输出的值，这些值将根据format字符串中的格式说明符进行格式化。返回值：
printf返回实际写入到标准输出的字符数。
int main() {
char name[20] = "zhangsan";
int age = 20;
float score = 95.5f;
//1.打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.写文件
//printf("%s %d %f", name, age, score);
fprintf(pf, "%s %d %f", name, age, score);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
运行，打开文件：
或者访问结构体变量：
struct S {
char name[20];
int age;
float score;
};
int main() {
struct S s = { "lisi",18,88.0f };
//1.打开文件
FILE* pf = fopen("test.txt", "w");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.写文件
//printf("%s %d %f", name, age, score);
fprintf(pf, "%s %d %f", s.name, s.age, s.score);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打开文件：
6.fscanf
fscanf
int fscanf ( FILE * stream, const char * format, ... );参数说明：
stream：指向要从中读取数据的文件流的指针。
format：一个字符串，包含普通文本和格式说明符。格式说明符用于指定如何解析输入的数据。
...：可变参数列表，包含用于存储解析结果的变量的地址。返回值：
fscanf返回成功解析并赋值的输入项的数量。如果到达文件末尾或发生错误，则返回EOF（End Of File，通常定义为-1）。
scanf
int scanf ( const char * format, ... );参数说明：
format：一个字符串，包含普通文本和格式说明符。格式说明符用于指定如何解析输入的数据。
...：可变参数列表，包含用于存储解析结果的变量的地址。返回值：
scanf返回成功解析并赋值的输入项的数量。如果到达输入流的末尾或发生错误，则返回EOF（End Of File，通常定义为-1）。
struct S {
char name[20];
int age;
float score;
};
int main() {
struct S s = { 0 };
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
//scanf("%s %d %f", s.name, &(s.age), &(s.score));//s.name拿到的是数组名，数组名本身就是地址，所以不要加&
fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));
//打印在屏幕上
printf("%s %d %f", s.name, s.age, s.score);
//fprintf(stdout ,"%s %d %f", s.name, s.age, s.score);//这个和上面那行作用一样
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
7.fwrite
fwrite
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );参数说明：
ptr：指向要写入数据的内存块的指针。
size：每个数据项的大小（以字节为单位）。
count：要写入的数据项的数量。
stream：指向要写入数据的文件流的指针。返回值：
fwrite返回成功写入的数据项的数量。如果发生错误或到达文件末尾，则返回一个小于 count 的值。就是把
ptr指向空间里面，count个大小为size个字节的元素的数据，写到stream里面去。
struct S {
char name[20];
int age;
float score;
};
int main() {
struct S s = { "cuihua", 25, 88.8f };
//以二进制形式写进文件
//1.打开文件
FILE* pf = fopen("test.txt", "wb");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.写文件
fwrite(&s, sizeof(struct S), 1, pf);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打开文件：
乱码是因为写的是二进制字符的原因。
8.fread
fread
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );参数说明：
ptr：指向用于存储读取数据的内存块的指针。
size：每个数据项的大小（以字节为单位）。
count：要读取的数据项的数量。
stream：指向要从中读取数据的文件流的指针。返回值：
fread返回成功读取的数据项的数量。如果到达文件末尾或发生错误，则返回一个小于 count 的值。就是把
steam指向空间里面（也就是文件里面读取），count个大小为size个字节的元素的数据，写到ptr里面去。
struct S {
char name[20];
int age;
float score;
};
int main() {
struct S s = { "cuihua", 25, 88.8f };
//读取二进制形式的信息写进文件中
//1.打开文件
FILE* pf = fopen("test.txt", "rb");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
fread(&s, sizeof(struct S), 1, pf);
printf("%s %d %f\n", s.name, s.age, s.score);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
5.2 对⽐⼀组函数：
scanf/fscanf/sscanf
printf/fprintf/sprintf
scanf/printf：针对 标准输入流/标准输出流 的 格式化输入/输出函数
fscanf/fprintf：针对 所有输入流/输出流 的 格式化输入/输出函数（也就是可以针对文件也可以针对标准输入/出流）
sscanf/sprintf：将格式化的数据转换成字符串，或者从字符串中提取格式化的数据
scanf
int scanf ( const char * format, ... );fscanf
int fscanf ( FILE * stream, const char * format, ... );sprintf
int sprintf ( char * str, const char * format, ... );
sprintf实际上就是将格式化的数据写到字符串中，可以理解为将格式化的数据转换成字符串
struct S {
char name[20];
int age;
float score;
};
int main() {
char arr[100] = { 0 };
struct S s = { "wangwu",23,66.6f };
//printf("%s %d %f", s.name, s.age, s.score);
sprintf(arr, "%s %d %f", s.name, s.age, s.score);
printf("%s\n", arr);
return 0;
}
打印：
后面打印的66.599998是因为这个6在内存里面是无法精确保存的。
scanf
int scanf ( const char * format, ... );fscanf
int fscanf ( FILE * stream, const char * format, ... );sscanf
int sscanf ( const char * s, const char * format, ...);
sscanf是从字符串中提取格式化的数据，可以理解为将字符串转换成格式化的数据
struct S {
char name[20];
int age;
float score;
};
int main() {
char arr[100] = { 0 };
struct S s = { "wangwu",23,66.6f };
//创建临时变量
struct S tmp = { 0 };
//将S中的各个数据转换成字符串，存放在arr中
sprintf(arr, "%s %d %f", s.name, s.age, s.score);
//从字符串arr中提取格式化的数据，存放在tmp中
//scanf("%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
sscanf(arr, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
printf("%s %d %f", tmp.name, tmp.age, tmp.score);
return 0;
}
打印：
6.文件的随机读写
6.1 fseek
根据文件指针的位置和偏移量来定位文件指针（文件内容的光标）。
int fseek ( FILE * stream, long int offset, int origin );
参数说明：
stream：指向要操作的文件流的指针。
offset：要移动的字节数。如果
origin是SEEK_SET，则offset是从文件开始处的偏移量；如果
origin是 SEEK_CUR ，则offset是从当前文件指针位置的偏移量；如果
origin是SEEK_END，则offset是从文件末尾的偏移量。
origin：指定offset的基准位置，可以是以下三个值之一：
SEEK_SET：从文件的开始位置移动。
SEEK_CUR：从当前文件指针位置移动。
SEEK_END：从文件的末尾位置移动。返回值：
fseek成功时返回0，失败时返回非零值。
例子：
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
我们要是想打印abe呢？
这个时候就要用到fseek函数了。
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//定位文件指针
fseek(pf, 4, SEEK_SET);
//fseek(pf, 2, SEEK_CUR);
//fseek(pf, -2, SEEK_END);
ch = fgetc(pf);//e
printf("%c\n", ch);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
6.2 ftell
返回文件指针相对于起始位置的偏移量
long int ftell ( FILE * stream );
参数说明：
stream：指向要查询的文件流的指针。返回值：
ftell返回当前文件指针的位置（以字节为单位），如果发生错误，则返回-1L。
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//定位文件指针
fseek(pf, 4, SEEK_SET);
ch = fgetc(pf);//e
printf("%c\n", ch);
//输出文件指针相较于文件起始位置的偏移量
printf("%d\n", ftell(pf));
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
为什么是5呢?
6.3 rewind
让文件指针的位置回到文件的起始位置
void rewind ( FILE * stream );
int main() {
//1.打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
//2.读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//定位文件指针
fseek(pf, 4, SEEK_SET);
ch = fgetc(pf);//e
printf("%c\n", ch);
//输出文件指针相较于文件起始位置的偏移量
printf("%d\n", ftell(pf));
//将文件指针重新定位到文件的起始位置
rewind(pf);
ch = fgetc(pf);//a
printf("%c\n", ch);
//3.关闭文件
fclose(pf);
pf = NULL;
return 0;
}
打印：
7.文件读取结束的判定
7.1 被错误使⽤的 feof
牢记：在文件读取过程中，不能用feof函数的返回值直接来判断文件的是否结束。
feof 的作用是：当文件读取结束的时候，判断读取结束的原因是否是：遇到文件尾结束。
因为文件读取结束有两个情况：遇到文件尾结束和读取错误。
文件读取结束判定的两个方法：
- 文本文件读取是否结束，判断返回值是否为
EOF（fgetc），或者NULL（fgets）例如：
fgetc判断是否为EOF.
fgets判断返回值是否为NULL.
- 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
fread判断返回值是否小于实际要读的个数。
文本文件的例子：
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
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);
}
二进制文件的例子：
#include <stdio.h>
enum { SIZE = 5 };
int main(void)
{
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);
}
接下来我们写个代码：
写之前创建一个test1.txt文件：
//拷贝文件
//test1.txt -->test2.txt
int main() {
//打开文件
FILE* pfread = fopen("test1.txt", "r");
if (pfread == NULL) {
perror("fopen\n");
return 1;
}
FILE* pfwrite = fopen("test2.txt", "w");
if (pfwrite == NULL) {
perror("fopen\n");
fclose(pfread);//第二个打开失败了就先把第一个文件关闭
return 1;
}
//读/写文件
int ch = 0;
while ((ch = fgetc(pfread)) != EOF) {
fputc(ch, pfwrite);
}
//关闭文件
fclose(pfread);
pfread = NULL;
fclose(pfwrite);
pfwrite = NULL;
return 0;
}
运行后：
8.文件缓冲区
ANSIC 标准采用“缓冲文件系统” 处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。
#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
FILE*pf = fopen("test.txt", "w");
fputs("abcdef", pf);//先将代码放在输出缓冲区
printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
Sleep(10000);
printf("刷新缓冲区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
//注：fflush 在高版本的VS上不能使用了
printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
Sleep(10000);
fclose(pf);
//注：fclose在关闭文件的时候，也会刷新缓冲区
pf = NULL;
return 0;
}
打印：
睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容
刷新缓冲区
再睡眠10秒-此时，再次打开test.txt文件，文件有内容了
-
睡眠10秒-已经写数据了，打开
test.txt文件，发现文件没有内容这个时候会自动创建一个文件
test.txt，里面是空的 -
刷新缓冲区
再睡眠10秒-此时，再次打开test.txt文件，文件有内容了这个时候文件里面会多出
abcdef。
这里可以得出一个结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区，或者在文件操作结束的时候关闭文件。
1915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
