文件操作不仅仅是我们使用鼠标用来操作文件的各项功能，还可以使用C语言来操作文件的内容，可以使用C语言来对文件的读、写、拷贝...等等，话不多说，直接开始：
目录
1.为什么要使用文件
我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很不方便，每一次进入都得重新保存联系人的信息。
因此我们想要将通讯录中的信息永久的保存下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。
使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化，就可以将联系人的信息保存下来，在下次再进入通讯录的时候之前保存的联系人的信息还存在。
2.什么是文件
磁盘上的文件是文件。
但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
2.1程序文件
包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
2.2数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。
在本期我们学习的是数据文件。
在之前的学习中，我们所处理的数据的输入输出都是以终端为对象，即从键盘上进行输入数据，然后将运行之后的结果显示到显示器上面。
编辑
其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
编辑
2.3文件名
一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：文件路径+文件名主干+文件后缀
例如： c:\code\test.txt
为了方便起见，文件标识常被称为文件名。
3.文件的打开和关闭
3.1文件指针
缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名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* pf;//文件指针变量
定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。
例如：
编辑
3.2文件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。
对于FILE指针变量的返回值需要进行判断。
在关闭文件之后及时置为NULL指针。
标准C规定：使用fopen函数用来打开文件，使用fclose来关闭文件：
编辑
打开方式：
编辑
//打开文件 FILE* fopen(const char* filename, const char* mode); //使用 //... //关闭文件 int fclose(FILE* stream);
打开方式：
| 文件使用方式 | 含义 | 如果指定文件不存在 |
| “r”（只读） | 为了输入数据，打开一个已经存在的文本文件 | 出错 |
| “w”（只写） | 为了输出数据，打开一个文本文件 | 建立一个新的文件 |
| “a”（追加） | 向文本文件尾添加数据 | 建立一个新的文件 |
| “rb”（只读） | 为了输入数据，打开一个二进制文件 | 出错 |
| “wb”（只写） | 为了输出数据，打开一个二进制文件 | 建立一个新的文件 |
| “ab”（追加） | 向一个二进制文件尾添加数据 | 出错 |
| “r+”（读写） | 为了读和写，打开一个文本文件 | 出错 |
| “w+”（读写） | 为了读和写，建立一个新的文件 | 建立一个新的文件 |
| “a+”（读写） | 打开一个文件，在文件尾进行读写 | 建立一个新的文件 |
| “rb+”（读写） | 为了读和写打开一个二进制文件 | 出错 |
| “wb+”（读写） | 为了读和写，新建一个新的二进制文件 | 建立一个新的文件 |
| “ab+”（读写） | 打开一个二进制文件，在文件尾进行读和写 | 建立一个新的文件 |
代码演示：
#include <stdio.h> int main() { //打开文件 //相对路径打开方式 //以写的方式打开，如果不存在test.txt这个文件就会重新创建一个文件 FILE* pf = fopen("test.txt", "w"); if (pf == NULL) { perror("fpoen:"); return 1; } //写文件 //... //关闭文件 fclose(pf); pf = NULL; return 0; }
上述代码就是相对路径的打开方式，打开本项目的文件。
也可以使用绝对路径来打开，打开的是别的路径下面的文件，比如我们在桌面上随机创建一个文件，然后将该文件的路径拷贝在我们的fopen函数里面就可以打开了。
#include <stdio.h> int main() { //打开文件 //绝对路径打开方式 //以写的方式打开，如果不存在test.txt这个文件就会重新创建一个文件 //这里要注意：一个文件的路径是"C:\Users\86188\Desktop\kawa.txt" //这里面就包含各种各样的转义字符，所以需要将\前面加上\转化为正常的字符 //C:\\Users\\86188\\Desktop\\kawa.txt FILE* pf = fopen("C:\\Users\\86188\\Desktop\\kawa.txt", "w"); if (pf == NULL) { perror("fpoen:"); return 1; } //写文件 //... //关闭文件 fclose(pf); pf = NULL; return 0; }
可以看到，文件操作的打开文件和关闭和动态内存开辟中的开辟空间和释放空间很相似，都在关闭之后将指针置为NULL指针。
4.文件的顺序读写
4.1顺序读写函数介绍
| 功能 | 函数名 | 适用于 |
| 字符输入函数 | fgetc | 所有输入流 |
| 字符输出函数 | fputc | 所有输出流 |
| 文本行输入函数 | fgets | 所有输入流 |
| 文本行输出函数 | fputs | 所有输出流 |
| 格式化输入函数 | fscanf | 所有输入流 |
| 格式化输出函数 | fprintf | 所有输出流 |
| 二进制输入 | fread | 文件 |
| 二进制输出 | fwrite | 文件 |
4.1.1fputc
字符输出函数：fputc（这里的输出指的不是程序输出到屏幕上，而是程序输出到文件中）
将读取到的字符写进文件中，一次只能写一个字符。
编辑
实例演示：将26个英文字母写进文件test.txt中
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.txt", "w"); //以w->写的方式打开 if (pf == NULL) { perror("fopen:"); return 1; } //写文件 //将26个英文字母输出到文件中 int i = 0; for (i = 0; i < 26; i++) { fputc('a' + i, pf); } //关闭文件 fclose(pf); pf = NULL; return 0; }
当程序运行成功之后，我们打开该程序路径下面的test.txt文件就会发现文件中出现了26个英文字母：
编辑
4.1.2fgetc
字符输入函数：fputc
将文件里面的字符读取然后输入到内存中，一次读取一个字符，并且读一次文件指针会向后面走一次，这样就避免了读取到的内容重复。
编辑
实例演示：将test.txt中的内容读取，然后打印至屏幕
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.txt", "r"); //以r->的方式打开文件 if (pf == NULL) { perror("fopen:"); return 1; } //读文件 int i = 0; int ch = 0; for (i = 0; i < 26; i++) { ch = fgetc(pf); printf("%c ", ch); } //关闭文件 fclose(pf); pf = NULL; return 0; }
编辑
4.1.3fputs
文本行输入函数：fputs
将字符串存放在文件中，但是不会将\0放进去。
编辑
实例演示：
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.txt", "w"); if (pf == NULL) { perror("fopen:"); return 1; } //写文件 char str[] = { "Hello World!" }; fputs(str, pf); //关闭文件 fclose(pf); pf = NULL; return 0; }
补充：
fputs在写数据的时候，如果写完一个字符串，在写一个字符串，那么写进去的两个数据是紧挨着的，如果想要换行，需要在每个数据的后面都加上\n来控制换行。
4.1.4fgets
文本行输入函数：fgets
编辑
编辑
读取结束后，如果读取成功，会自动在str后面添加上\0
实例演示：
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.txt", "r"); if (pf == NULL) { perror("fopen:"); return 1; } //读取文件 char str[256] = { 0 }; fgets(str, 4, pf); printf("%s\n", str); //关闭文件 fclose(pf); pf = NULL; return 0; }
4.1.5fprintf
格式化输出函数：fprintf
想要往文件里面存放非字符的数据就可以使用格式化的输出，我们先来观察一下这个函数：
编辑
如果单纯的看这个函数，会发现不知道该从哪里下手，但是如果将它和printf来对比的话就会发现其实很简单：
编辑
相对于printf函数来讲fprintf多了一个文件指针，那么我们就可以在使用printf的基础上再加上一个文件指针就可以了。
实例演示：
#include <stdio.h> struct S { int num; float f; char name[20]; }; int main() { struct S s = { 2023,3.14f,"zhangsan" }; //打开文件 FILE* pf = fopen("test.txt", "w"); if (pf == NULL) { perror("fopen:"); return 1; } //格式化写文件 //对比来使用 //printf printf("%d %f %s", s.num, s.f, s.name); //fprintf fprintf(pf, "%d %f %s", s.num, s.f, s.name); //关闭文件 fclose(pf); pf = NULL; return 0; }
4.1.6fscanf
格式化输入函数：fscanf
进行格式化的读取，同样的，我们将它和scanf函数来进行对比的来使用：
编辑
实例演示：
#include <stdio.h> struct S { int num; float f; char name[20]; }; int main() { struct S s = { 0 }; //打开文件 FILE* pf = fopen("test.txt", "r"); if (pf == NULL) { perror("fopen:"); return 1; } //格式化的输入 //对比来使用 //scanf("%d %f %s", &(s.num), &(s.f), s.name); fscanf(pf, "%d %f %s", &(s.num), &(s.f), s.name); printf("%d %f %s", s.num, s.f, s.name); //关闭文件 fclose(pf); pf = NULL; return 0; }
补充：
上面都有关于流的概念，那这个概念到底是什么呢？
流一共包括四部分：
编辑
当C程序运行起来之后会默认打开三个流：
编辑
这也就是为什么我们在进行scanf和printf的时候不需要像文件操作这样麻烦，我们再回过头来看这些函数的适用范围：
编辑
既然它们有的适用于所有流，那么也可以使用它们来正常的进行输入输出：
struct S { int num; float f; char name[20]; }; #include <stdio.h> int main() { struct S s = { 2023,3.14f,"zhangsan" }; //标准输入流 int ch = fgetc(stdin); printf("%c\n", ch); //标准输出流 fputc('a', stdout); fputc('b', stdout); fputc('c', stdout); // fprintf(stdout, "%d %f %s", s.num, s.f, s.name); //也可以进行输入 //struct S s = { 0 }; //fscanf(stdin,"%d %f %s",&(s.num),&(s.f),s.name); return 0; }
注意：这里的stdin、stdout、stderr都是FILE* 的指针变量。
4.1.7fwrite
二进制函数:fwrite
以二进制的方式将数据输出到文件中：
编辑
编辑
实例演示：
#include <stdio.h> struct S { char name[20]; char age; float weight; }; int main() { struct S s = { "zhangsan",16,65.5f }; //打开文件 FILE* pf = fopen("text.txt", "wb"); //二进制写的方式打开 if (pf == NULL) { perror("fopen:"); return 1; } //写文件 fwrite(&s, sizeof(struct S), 1, pf); //将s中的数据输出到pf中，一次输出一个数据 //关闭文件 fclose(pf); pf = NULL; return 0; }
编辑
可以看到，以二进制写进文件的数据当我们在打开的时候发现有一部分是我们看不懂的，因为我们打开的文件是文本文件，但是我们是以二进制的方式写进去的，所以有的数据就会转化为我们不能肉眼能看到的数据，前面我们将数据写入文件是以文本的方式输出到文件中的，所以我们可以直观的看到，那么既然我们读不懂二进制的文件，那么就需要使用fread来以二进制的方式来读取文件。
4.1.8fread
二进制输入：fread
以二进制的方式来读取文件：
编辑
编辑
实例演示：
#include <stdio.h> struct S { char name[20]; char age; float weight; }; int main() { struct S s = { 0 }; //打开文件 FILE* pf = fopen("text.txt", "rb"); //二进制读的方式打开 if (pf == NULL) { perror("fopen:"); return 1; } //写文件 fread(&s, sizeof(struct S), 1, pf); //将文件pf中的数据读取到s中，一次输出一个数据 printf("%s %d %f\n", s.name, s.age, s.weight); //关闭文件 fclose(pf); pf = NULL; return 0; }
编辑
可以看到使用fread可以很好的将文本文件中的二进制数据读取出来转变成我们可以直观看到的数据。
补充：
关于fread函数的返回值我们可以来看一下：
编辑
fread函数的返回值表示实际读取到的元素的个数，举个例子，假设我们打开的文件中有3个元素，但是我们在设置的时候设置读取5个元素，但是文件中只有3个元素，所以fread会返回3，假设文件中有8个元素，我们设置读取5个元素，当第一次读取的时候，返回的是5，但是还剩下3个元素没有读取，那么第二次再读取的时候会返回3。
学到这里呢我们就可以将我们之前写的动态版本的通讯录进行改造，在动态版本的通讯录里面我们使通讯录的容量是一个动态值，那么在使用文件操作改造之后我们就可以将通讯录的联系人保存在文件中，当下一次再进入通讯录的时候之前保存的联系人的信息都可以很好的保存下来：通讯录（文件版本）
4.2对比一组函数
scanf / fscanf / sscanf
printf / fprintf / sprintf
4.2.1sprintf
将格式化输入的数据写进一个字符串中，并且会自动在末尾加上\0
编辑
实例演示：
#include <stdio.h> struct S { int num; float f; char name[20]; }; int main() { struct S s = { 2023,6.66f,"lisi" }; char str[256] = { 0 }; //将格式化的数据写进字符串中 sprintf(str, "%d %f %s\n", s.num, s.f, s.name); printf("字符串的数据: %s\n", str); return 0; }
编辑
4.2.2sscanf
把一个字符串转化成对应的格式化的数据：
编辑
实例演示：
#include <stdio.h> struct S { int num; float f; char name[20]; }; int main() { struct S s = { 2023,6.66f,"lisi" }; char str[256] = { 0 }; //将格式化的数据写进字符串中 sprintf(str, "%d %f %s\n", s.num, s.f, s.name); printf("字符串的数据: %s\n", str); //将一个字符串中的数据转化为对应的格式化数据 struct S tmp = { 0 }; sscanf(str, "%d %f %s", &(tmp.num), &(tmp.f), tmp.name); printf("格式化的数据: %d %f %s\n", tmp.num, tmp.f, tmp.name); return 0; }
编辑
4.2.3对比
scanf：针对标准输入流（stdin）的格式化输入函数
printf：针对标准输出流（stdout）的格式化输出函数
fscanf：针对所有输入流（文件流/stdin）的格式化输入函数
fprintf：针对所有输出流（文件流/stdout）的格式化输出函数
sscanf：把字符串转化为格式化的数据
sprintf：把格式化的数据转化为字符串
5.文件的随机读写
5.1fseek
根据文件指针的位置和偏移量来定位文件指针。
编辑
这里重点来看一下它的第三个函数参数：
编辑
实例演示：
那既然要读取文件，所以我们先创建一个文本文件，然后写点东西进去：
编辑
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.dat", "r"); if (pf == NULL) { perror("fopen:"); return 1; } //读取文件 char ch = 0; //先读一次 ch = fgetc(pf); printf("%c ", ch); //读到的是a //读第二次 ch = fgetc(pf); printf("%c ", ch); //b //.. ch = fgetc(pf); printf("%c ", ch); //c ch = fgetc(pf); printf("%c ", ch); //d ch = fgetc(pf); printf("%c ", ch); //e //如果要返回去再读一次c fseek(pf, -3, SEEK_CUR); //从文件指针的当前位置开始读取 //在读完e之后的文件指针已经指向了f， //所以再要返回读c，文件指针的偏移量就是-3 //当然可以从文件指针的起始位置读取 ch = fgetc(pf); printf("%c ", ch); //c //关闭文件 fclose(pf); pf = NULL; return 0; }
编辑
5.2ftell
返回文件指针相对于起始位置的偏移量：
编辑
编辑
实例演示：
我们还是使用上面的案例来看一下读到e时的偏移量：
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.dat", "r"); if (pf == NULL) { perror("fopen:"); return 1; } //读取文件 char ch = 0; //先读一次 ch = fgetc(pf); printf("%c ", ch); //读到的是a //读第二次 ch = fgetc(pf); printf("%c ", ch); //b //.. ch = fgetc(pf); printf("%c ", ch); //c ch = fgetc(pf); printf("%c ", ch); //d ch = fgetc(pf); printf("%c ", ch); //e // printf("%d\n", ftell(pf)); //关闭文件 fclose(pf); pf = NULL; return 0; }
编辑
5.3rewind
让文件指针的位置回到文件的起始位置：
编辑
无返回类型
实例演示：
同样我们还是使用上面案例的代码来做演示：
#include <stdio.h> int main() { //打开文件 FILE* pf = fopen("test.dat", "r"); if (pf == NULL) { perror("fopen:"); return 1; } //读取文件 char ch = 0; //先读一次 ch = fgetc(pf); printf("%c ", ch); //读到的是a //读第二次 ch = fgetc(pf); printf("%c ", ch); //b //.. ch = fgetc(pf); printf("%c ", ch); //c ch = fgetc(pf); printf("%c ", ch); //d ch = fgetc(pf); printf("%c ", ch); //e //文件指针偏移量 printf("%d\n", ftell(pf)); //将文件指针回到起始位置 rewind(pf); printf("%d ", ftell(pf)); //将文件指针恢复到起始位置时再读一次 ch = fgetc(pf); printf("%c ", ch); //关闭文件 fclose(pf); pf = NULL; return 0; }
6.文本文件和二进制文件
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2019测试）。
代码测试：
#include <stdio.h> int main() { int a = 10000; //以二进制写的方式打开 FILE* pf = fopen("test.txt", "wb"); if (pf == NULL) { perror("fopen:"); return 1; } //以二进制写的文件 fwrite(&a, sizeof(int), 1, pf); //关闭文件 fclose(pf); pf = NULL; return 0; }
编辑
文本文件：
编辑
我们也可以在编译器上面观察二进制文件：
编辑
编辑
编辑
编辑
7.文件读取结束的判断
7.1被错误使用的feof
牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。
而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。
1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
例如：
fgetc 判断是否为 EOF .
fgets 判断返回值是否为 NULL .
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
fread判断返回值是否小于实际要读的个数。
7.2正确的feof使用方法
7.2.1文本文件
fgetc函数的返回值分析：
编辑
fgetc函数读取失败会返回EOF：
1.遇到文件末尾，返回EOF，同时设置一个遇到文件末尾的状态，然后使用feof来检测这个状态。
2.遇到错误，返回EOF，同时设置一个读取错误的状态，可以使用ferror来检测这个状态。
#include <stdio.h> int main() { FILE* pf = fopen("test.txt", "r"); if (pf == NULL) { perror("fopen:"); return 1; } // char ch = 0; while ((ch = fgetc(pf)) != EOF) { printf("%c", ch); } //判断读取结束信息 if (feof(pf)) printf("End of file reached successfully\n"); else if (ferror(pf)) printf("I/O error when reading\n"); // fclose(pf); pf = NULL; return 0; }
7.2.2二进制文件
#include <stdio.h> enum { SIZE = 5 }; int main(void) { double a[SIZE] = { 1.,2.,3.,4.,5. }; //打开文件 FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式 if (fp == NULL) { perror("fopen:"); return 1; } //写文件 fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组 //关闭文件 fclose(fp); fp = NULL; double b[SIZE]; //打开文件 fp = fopen("test.bin", "rb"); if (fp == NULL) { perror("fopen:"); return 1; } size_t ret_code = fread(b, sizeof * b, SIZE, fp); // 读 double 的数组 if (ret_code == SIZE) //如果读到的数据刚好是5 { 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); fp = NULL; }
总结：
feof并不是用来判断文件是否结束，而是在文件已经读取结束后，来判断是由什么原因导致文件读取结束的。
8.文件缓冲区
ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。
编辑
可以使用代码来感觉到这个缓冲区的存在：
#include <stdio.h> #include <windows.h> //VS2019 WIN11环境测试 int main() { FILE* pf = fopen("test.txt", "w"); if (pf == NULL) { perror("fopen:"); return 1; } 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; }
编辑
结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。
如果不做，可能导致读写文件的问题。
9.小练习：拷贝文件
将一个文件中的内容拷贝至另外一个文件：
思路：打开两个文件：一个是被读的文件，一个是要写的文件，然后从被读的文件里面读取数据，每读取一个数据就写进要写的文件里面。
编辑
也就是将test1.txt中的内容重新放进一个test2.txt的文件中。
代码演示：
#include <stdio.h> int main() { //打开被读的文件 FILE* pfRead = fopen("test1.txt", "r"); if (pfRead == NULL) { perror("open file for read"); return 1; } //打开要写的文件 FILE* pfWrite = fopen("test2.txt", "w"); if (pfWrite == NULL) { //如果要写的文件打开失败最好是吧被读的文件关闭 fclose(pfRead); pfRead = NULL; perror("open file for write"); return 1; } //拷贝 char ch = 0; while ((ch = fgetc(pfRead)) != EOF) { fputc(ch, pfWrite); } //关闭文件 fclose(pfRead); pfRead = NULL; fclose(pfWrite); pfWrite = NULL; return 0; }
编辑
C语言有关文件操作的相关知识点就分享到这里了，如果大家喜欢，请留下你的三连，感谢各位老铁的阅览！
