文章详细介绍了C语言中文件的基本操作，包括文件的打开与关闭、顺序读写、随机读写，以及文本文件和二进制文件的区别。重点讲解了fopen、fclose、fgetc、fputc、fgets、fputs、fscanf、fprintf、fread、fwrite等函数的使用，并给出了多个示例。此外，还讨论了文件结束判定的正确方法，强调了feof函数的使用时机以及文件缓冲区的重要性。
目录
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*的指针变量:
FILE*pf;//文件指针变量定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。
比如：
3.2文件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。
ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件。
fopen（打开文件）
FILE * fopen ( const char * filename, const char * mode );
参数：
- const char * filename：文件名称
- const char * mode：访问文件的方式
如果文件被成功打开，函数将返回一个指向FILE对象的指针，该对象可用于识别未来操作中的流。否则，将返回一个空指针。
fclose（关闭文件）
int fclose ( FILE * stream );
参数：
- FILE * stream ：指向FILE对象的指针，该对象指定要关闭的流。
如果成功关闭，则返回零值。失败，返回EOF。
打开方式（或者说访问文件的方式）如下：
| 文件使用方式 | 含义 | 如果指定文件不存在 |
|---|---|---|
| "r"(只读) | 为了输入数据，打开一个已经存在的文本文件 | 出错 |
| "w"(只写) | 为了输出数据，打开一个文本文件 | 建立一个新的文件 |
| "a"(追加) | 向文本文件末尾添加数据 | 建立一个新的文件 |
| "rb"(只读) | 为了输入数据，打开一个二进制文件 | 出错 |
| "wb"(只写) | 为了输出数据，打开一个二进制文件 | 建立一个新的文件 |
| "ab"(追加) | 向二进制文件末尾添加数据 | 出错 |
| "r+"(读写) | 为了读和写，打开一个文本文件 | 出错 |
| "w+"(读写) | 为了读和写，建立一个文本文件 | 建立一个新的文件 |
| "a+"(读写) | 打开一个文件，在文件末尾进行读写 | 建立一个新的文件 |
| "w"(读写) | 为了读和写，打开一个二进制文件 | 出错 |
| "a+"(读写) | 为了读和写，新建一个新的二进制文件 | 建立一个新的文件 |
| "a+"(读写) | 打开一个二进制文件，在文件末尾进行读写 | 建立一个新的文 |
实例：
int main()
{
//打开文件
FILE* pf = fopen("test.dat", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
// ……
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
运行代码后， test.dat这个文件就被创建了。
4.文件的顺序读写
4.1 fgetc 字符输入函数
int fgetc ( FILE * stream );
参数：
FILE * stream：指向标识输入流的FILE对象的指针。
功能：
从流中获取字符。返回指定流的内部文件位置指示器当前指向的字符。然后，内部文件位置指示器将前进到下一个字符。
如果调用时流位于文件结尾，则函数返回EOF并设置流的文件结尾指示符（feof）。
如果发生读取错误，函数将返回EOF并设置流的错误指示器（ferror）。
例：
int main()
{
//打开文件
FILE* pf = fopen("test.dat", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
int ret = fgetc(pf);
printf("%c\n", ret);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
a
与test.dat中的内容对比，显然无误。
4.2 fputc 字符输出函数
int fputc ( int character, FILE * stream );
参数：
int character：要写入的字符。
FILE * stream：指向标识输出流的FILE对象的指针。
功能：向流中写入一个字符并使位置指示器前进。成功后，所写的字符将被返回。如果发生写入错误，则返回EOF并设置错误指示器（ferror）。
例：
int main()
{
//打开文件
FILE* pf = fopen("test.dat", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fputc("1", pf);
fputc("2", pf);
fputc("3", pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行代码后：
4.3 fgets 文本行输入函数
char * fgets ( char * str, int num, FILE * stream );
参数：
- char * str：指向将读取的字符串复制到其中的字符数组的指针。
- int num：要复制到str中的最大字符数（包括终止的null字符）。
- FILE * stream：指向标识输入流的FILE对象的指针。
功能：
从流中读取字符，并将其作为C字符串存储到str中，直到读取（num-1）个字符，或者到达换行符或文件结尾，以先发生的为准。
换行符会使fgets停止读取，但函数会将其视为有效字符，并将其包含在复制到str的字符串中。
在复制到str的字符之后会自动附加一个终止的null字符。
成功后，函数返回str。如果发生读取错误，则会设置错误指示器（ferror），并返回一个空指针（但str指向的内容可能已更改）。
例：
int main()
{
//打开文件
FILE* pf = fopen("test.dat", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//操作文件
char ch[20] = { 0 };
if (fgets(ch, 6, pf) == NULL)
{
perror("fgets");
}
else
{
puts(ch);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}test.dat文件
输出：
a lem
代码中要求输出6个字符，因为fgets函数会在字符串末尾自动加一个\0，所以只读取了文件的前5个字符，a，空格，l , e , m 正好5个字符。
4.4 fputs 文本行输出函数
int fputs ( const char * str, FILE * stream );
参数：
- const char * str : 具有要写入流的内容的C字符串。
- FILE * stream：指向标识输出流的FILE对象的指针。
功能：
将str指向的C字符串写入流。函数开始从指定的地址（str）复制，直到到达终止的null字符（“\0”）。此终止的null字符不会复制到流中。
成功后，将返回一个非负值。出现错误时，该函数返回EOF并设置错误指示器（ferror）。
例：
int main()
{
//打开文件
FILE* pf = fopen("test.dat", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//操作文件
const char* str = "apple";
if (fputs(str, pf) == EOF)
perror("fputs");
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行代码后：
4.5 fscanf 格式化输入函数
int fscanf ( FILE * stream, const char * format, ... );
参数：
- FILE * stream：指向FILE对象的指针，该对象标识要从中读取数据的输入流。
- const char * format：参数格式
- ...：可变参数，即参数的个数是可以发生改变的。
功能：
从流中读取数据，并根据参数格式将其存储到附加参数所指向的位置。
例：
int main()
{
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//操作文件
float f = 0;
fscanf(pf, "%f", &f);
printf("%f\n", f);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
5.000000
4.6 fprintf 格式化输出函数
int fprintf ( FILE * stream, const char * format, ... );
参数：
- FILE * stream：指向标识输出流的FILE对象的指针。
- const char * format：C字符串，其中包含要写入流的文本。
- ...：可变参数，即参数的个数是可以发生改变的。
功能：将格式化指向的C字符串写入流。成功后，将返回写入的字符总数。如果发生写入错 误，则设置错误指示器（ferror）并返回负数。
例：
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s = { "abcde",20, 5.5f };
//打开文件
FILE* pf = fopen("text.dat", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//操作文件
fprintf(pf,"%s %d %f\n",s.arr,s.age,s.f);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行代码后：
4.7 fread 二进制输入
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
参数：
- void * ptr ：指向大小至少为（size*count）字节的内存块的指针，该内存块已转换为空*。
- size_t size : 要读取的每个元素的大小（以字节为单位）。
- size_t count : 元素的数量，每个元素的大小为字节。
- FILE * stream : 指向指定输入流的FILE对象的指针
功能：从流中读取count个元素的数组，每个元素的大小为字节，并将它们存储在ptr指定的内存块中。成功，返回读取的元素总数。如果此数字与count参数不同，则表示发生读取错误，或者读取时已到达文件末尾。如果大小或计数为零，则函数返回零，并且ptr所指向的流状态和内容保持不变。
例：
text.dat中的内容是二进制形式。
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s = {0};
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//操作文件
fread(&s, sizeof(struct S), 1, pf);
printf("%s %d %f\n", s.arr, s.age, s.f);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
abcde 20 5.500000
4.8 fwrite 二进制输出
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
参数：
- const void * ptr ：指向要写入的元素数组的指针，转换为常量void*。
- size_t size : 要写入的每个元素的大小（以字节为单位）。
- size_t count : 元素的数量，每个元素的大小为字节。
- FILE * stream : 指向指定输出流的FILE对象的指针
功能：从ptr指向的内存块向流中的当前位置写入count个元素的数组，每个元素的大小为字节。成功,返回写入的元素总数。如果此数字与计数参数不同，则写入错误会阻止函数完成。在这种情况下，将为流设置错误指示器（ferror）。如果大小或计数为零，则函数返回零，并且错误指示器保持不变。
例：
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s = { "abcde",20, 5.5f };
//打开文件
FILE* pf = fopen("text.dat", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//操作文件
fwrite(&s, sizeof(struct S), 1, pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行代码后：
字符串以二进制的形式和以文本的形式写入文件的方式差不多，所以我们能看懂。但是整数，浮点数以二进制的形式和以文本的形式写入文件的方式不同，看不到很正常。
4.9对比一组函数
sprintf
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s = { "apple",30,4.4f };
char buf[100] = { 0 };
sprintf(buf, "%s %d %f", s.arr, s.age, s.f);
printf("%s\n", buf);
return 0;
}输出：
apple 30 4.400000
sscanf
struct S
{
char arr[10];
int age;
float f;
};
int main()
{
struct S s = { "apple",30,4.4f };
struct S tmp = { 0 };
char buf[100] = { 0 };
sprintf(buf, "%s %d %f", s.arr, s.age, s.f);
printf("%s\n", buf);
sscanf(buf, "%s %d %f", tmp.arr, &tmp.age, &tmp.f);
printf("%s %d %f\n", tmp.arr, tmp.age, tmp.f);
return 0;
}输出：
apple 30 4.400000
apple 30 4.400000
5.文件的随机读写
5.1fseek
int fseek ( FILE * stream, long int offset, int origin );
参数：
- FILE * stream：指向FILE结构的指针
- long int offset：从原点偏移的字节数
- int origin：初始位置（有3种，SEEK_CUR，SEEK_END，SEEK_SET看下图）
功能：将文件指针移动到指定位置。如果成功，fseek将返回0。否则，它将返回一个非零值。
例：
int main()
{
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
printf("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;
}输出：
a
b
c
这是按顺序读写的，如果我想跳过b、c，直接读取d呢？
int main()
{
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
printf("fopen");
return 1;
}
//读取文件
int ch = fgetc(pf);
printf("%c\n", ch);
//调整文件指针
fseek(pf, 2, SEEK_CUR);
ch = fgetc(pf);
printf("%c\n", ch);
ch = fgetc(pf);
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
a
d
e
也可以向左偏移：
int main()
{
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
printf("fopen");
return 1;
}
//读取文件
int ch = fgetc(pf);
printf("%c\n", ch);
//调整文件指针
fseek(pf, -1, SEEK_CUR);
ch = fgetc(pf);
printf("%c\n", ch);
ch = fgetc(pf);
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
a
a
b
5.2 ftell
long int ftell( FILE *stream );
参数：
- FILE *stream：指向标识流的FILE对象的指针。
功能：获取流中的当前位置。
成功后，将返回位置指示器的当前值。
失败时，返回-1L，errno设置为系统特定的正值。
例：
int main()
{
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
printf("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);
int ret=ftell(pf);
printf("%d\n", ret);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
a
b
c
3
5.3 rewind
void rewind ( FILE * stream );
参数：
- FILE *stream：指向标识流的FILE对象的指针。
功能：将文件指针重新定位到文件的开头。
例：
int main()
{
//打开文件
FILE* pf = fopen("text.dat", "r");
if (pf == NULL)
{
printf("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);
//回到文件开端
rewind(pf);
ch = fgetc(pf);
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
a
b
c
a
6.文本文件和二进制文件
根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
- 数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
- 如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在文件中是怎么存储的呢？
- 字符一律以ASCII形式存储
- 数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2013测试）。
int main()
{
int a = 10000;
FILE* pf = fopen("text.txt", "wb");
if (pf==NULL)
{
perror("fopen");
return 1;
}
fwrite(&a, sizeof(int), 1, pf);
fclose(pf);
return 0;
}运行代码后：
7.文件读取结束的判定
7.1被错误使用的feof
int feof( FILE *stream );
参数：
- 指向FILE结构的指针
功能：测试流上的文件结尾。feof函数在尝试读取超过文件末尾的第一次读取操作之后返回一个非零值。如果当前位置不是文件末尾，则返回0。
牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。
而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。
1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
- fgetc函数在读取结束的时候，会返回EOF ，正常读取时，返回的是读取到的字符的ASCII码值
- fgets函数在读取结束的时候，会返回NULL ，正常读取时，返回的是存放字符串的空间起始地址
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
- fread函数在读取的时候，返回的是实际读取到的完整元素的个数，如果发现读取到的完整的元素的个数小于指定的元素的个数，这就是最后一次读取。
正确的使用：
文本文件的例子：
int main()
{
int c = 0;
//打开文件
FILE* pf = fopen("text.dat", "r");
if (!pf)
{
printf("fopen");
return 1;
}
//fgetc当读取失败的时候或者遇到文件结束的时候，都会返回EOF
while ((c = fgetc(pf)) != EOF)
{
putchar(c);
}
//判断是什么原因结束的
if (ferror(pf))
puts("\nI/O error when reading");
else if (feof(pf))
puts("\nEnd of file reached successful");
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}输出：
abcde
End of file reached successful
二进制文件的例子：
enum{SIZE=5};
int main()
{
double a[SIZE] = { 1.,2.,3.,4.,5. };
FILE* pf = fopen("test.bin", "wb");//必须用二进制模式
fwrite(a, sizeof * a, SIZE, pf);
fclose(pf);
pf = NULL;
double b[SIZE];
pf = fopen("test.bin", "rb");
size_t ret_code = fread(b, sizeof * b, SIZE, pf);//读double的数组
if (ret_code == SIZE)
{
puts("Array read successful,contents:");
for (int n = 0; n < SIZE; ++n)
printf("%f", b[n]);
putchar('\n');
}
else
{
//error handling
if (feof(pf))
printf("Error reading test.bin:unexpected end of file\n");
else if(feof(pf))
{
perror("Error reading test.bin");
}
}
fclose(pf);
pf = NULL;
return 0;
}输出：
Array read successful,contents:
1.0000002.0000003.0000004.0000005.000000
把text.txt文件拷贝一份，生成test2.txt
//把text.txt文件拷贝一份，生成test2.txt
int main()
{
FILE* pfread = fopen("text.txt", "r");
if (pfread = NULL)
{
perror("fopen");
return 1;
}
FILE* pfwrite = fopen("text2.txt", "w");
if (pfwrite = NULL)
{
fclose(pfread);//既然走到这一步，说明text.txt打开成功，如果text2.txt打开失败，程序自动结束，所以在这里要关闭text.txt。
pfread = NULL;
perror("fopen");
return 1;
}
//文件打开成功
int ch = 0;
while (ch = fgetc(pfread) != EOF)
{
//写文件
fputc(ch, pfwrite);
}
if (feof(pfread))
printf("遇到文件结束标志，文件正常结束\n");
else if (ferror(pfread))
printf("文件读取失败结束\n");
//关闭文件
fclose(pfread);
pfread = NULL;
fclose(pfwrite);
pfwrite = NULL;
return 0;
}运行代码后：
8.文件缓冲区
ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。
int main()
{
FILE* pf = fopen("text.txt", "w");
fputs("abcdef", pf);//先将代码放在输出缓冲区
printf("睡眠10秒-已经开始写数据了，打开text.txt文件，发现文件没有内容\n");
Sleep(10000);
printf("刷新缓冲区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
//fflush在高版本的VS上不能使用了
printf("再睡眠10秒-此时打开text.txt文件，文件有内容了\n");
Sleep(10000);
fclose(pf);
//fclose在关闭文件的时候，也会刷新缓冲区
pf = NULL;
return 0;
}输出：
睡眠10秒-已经开始写数据了，打开text.txt文件，发现文件没有内容
刷新缓冲区
再睡眠10秒-此时打开text.txt文件，文件有内容了
跟随输出观察文件
结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。
如果不做，可能导致读写文件的问题。
1940
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
