C语言-文件系统详解（三）-阿里云开发者社区

文件的顺序读写

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

流的含义：

清除test.data的内容：使用w方式打开文件，并且不写入，会将文件中的内容清空

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. int main()
5. {
6.  //打开文件
7.  FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "w");
8. 
9.  //文件操作
10.   if (pf == NULL)
11.   {
12.     perror("fopen");
13.     return 1;
14.   }
15. 
16.   //关闭文件
17.   fclose(pf);
18.   pf = NULL;
19.   return 0;
20. }

ctrl+F5运行，打开test.data文件，内容被清空：

fputc

int fputc ( int character, FILE * stream );//写入成功，则返回写入的字符

fputc支持所有输出流，所以fputc向文件和屏幕上都可以写入内容

（1）向文件写入内容：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. int main()
5. {
6.  //打开文件
7.  FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "w");
8. 
9.  //文件操作
10.   if (pf == NULL)
11.   {
12.     perror("fopen");
13.     return 1;
14.   }
15. 
16.   fputc('h', pf);
17.   fputc('e', pf);
18.   fputc('l', pf);
19.   fputc('l', pf);
20.   fputc('o', pf);
21. 
22.   //关闭文件
23.   fclose(pf);
24.   pf = NULL;
25.   return 0;
26. }

ctrl+F5运行，打开test.data文件，结果为：

（2）向屏幕输出信息：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  fputc('h', stdout);
6.  fputc('e', stdout);
7.  fputc('l', stdout);
8.  fputc('l', stdout);
9.  fputc('o', stdout);
10. }

ctrl+F5运行，将hello打印在屏幕上：

fgetc

int fgetc ( FILE * stream );//读取成功则返回读取到的字符

fgetc支持所有输入流，fgetc从文件和屏幕上都可以读取内容

（1）fgetc从文件里面读取字符，先手动将test.data里面的内容改为world

读取文件内容前3个字符：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  //打开文件
6.  FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "r");//读取
7. 
8.  //文件操作
9.  if (pf == NULL)
10.   {
11.     perror("fopen");
12.     return 1;
13.   }
14. 
15.   int ret = fgetc(pf);
16.   printf("%c", ret);
17.   ret = fgetc(pf);
18.   printf("%c", ret);
19.   ret = fgetc(pf);
20.   printf("%c", ret);
21. 
22.   return 0;
23. }

ctrl+F5运行，读取到前3个字符

（2）fgetc也可以从标准输入读取字符

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  int ret = fgetc(stdin);
6.  printf("%c", ret);
7.  ret = fgetc(stdin);
8.  printf("%c", ret);
9.  ret = fgetc(stdin);
10.   printf("%c", ret);
11. 
12.   return 0;
13. }

ctrl+F5运行，输入字符串，读取到前3个字符

fputc和fgetc每读一次，相当于指针+1，读取结束会返回EOF(-1)。

fputs

int fputs ( const char * str, FILE * stream );//以文本（ASCII码）方式写入成功则返回一个非负值

fputs向所有输出流写入文本行

（1）向文件test.data文件中写入字符串：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "w");
6.  if(pf == NULL)
7.  {
8.    perror("fopen");
9.    return 1;
10.   }
11. 
12.   //写文件-按照行来写
13.   fputs("abcd", pf);
14.   fputs("efg", pf);
15. 
16.   //关闭文件
17.   fclose(pf);
18.   pf = NULL;
19.   return 0;
20. }

ctrl+F5运行，两行字符串写入到test.data文件中。

如果需要换行，写入的字符串末尾加上换行符即可：

1.     //写文件-按照行来写
2.  fputs("abcd\n", pf);
3.  fputs("efg", pf);

fgets

char * fgets ( char * str, int num, FILE * stream );//以文本方式读取字符，num是最大读取字符数，不定义时为99，最后一个为\0。

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  char arr[10] = { 0 };
6.  FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "r");
7.  if (pf == NULL)
8.  {
9.    perror("fopen");
10.     return 1;
11.   }
12. 
13.   //读文件
14.   fgets(arr,4, pf);//实际上最多读取3个字符，最后一个字符是\0
15.   printf("%s\n", arr);
16. 
17.   fgets(arr, 4, pf);//实际上最多读取3个字符，最后一个字符是\0
18.   printf("%s\n", arr);
19. 
20.   fgets(arr, 4, pf);//实际上最多读取3个字符，最后一个字符是\0
21.   printf("%s\n", arr);
22. 
23.   //关闭文件
24.   fclose(pf);
25.   pf = NULL;
26.   return 0;
27. }

ctrl+F5运行，结果如下：

fprintf

把格式化数据写入到流中

int fprintf ( FILE * stream, const char * format, ... )//读取成功就返回读取到的字符个数，否则返回负数

返回值为int的原因有两个：字符是用ASCII码表示的；函数在读取失败会返回EOF(-1)，char（1-255）没办法存-1，int可以存-1。

fprintf和printf对比，fprintf比printf多了一个参数：FILE流参数。

使用fprintf把格式化数据写入到流中

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. struct S
5. {
6.  char c[20];
7.  int i;
8.  float f;
9. };
10. 
11. int main()
12. {
13.   struct S s = { "abcdef",10,5.5f };
14. 
15.     //对格式化的数据进行写文件
16.   FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "w");
17.   if (NULL == pf)
18.   {
19.     perror("fopen");
20.     return 1;
21.   }
22. 
23.   //写文件
24.   fprintf(pf, "%s %d %f", "hello", 5, 2.6);
25. 
26.     //关闭文件
27.   fclose(pf);
28.   pf = NULL;
29. 
30.   return 0;
31. }

ctrl+F5，查看运行结果：

fscanf

从流中读取格式化数据

int fscanf ( FILE * stream, const char * format, ... );//根据格式读取并存储流中的数据

fscanf和scanf对比，fscanf比scanf多了一个参数：FILE流参数。

使用fscanf把格式化数据读取到流中

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. struct S
5. {
6.  char c[20];
7.  int i;
8.  float f;
9. };
10. 
11. int main()
12. {
13.   struct S s = { "abcdef",10,5.5f };
14.   //对格式化的数据进行写文件
15.   FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "r");//读取
16.   if (NULL == pf)
17.   {
18.     perror("fopen");
19.     return 1;
20.   }
21. 
22.   //写文件
23.   fscanf(pf, "%s %d %f", s.c, &(s.i), &(s.f));
24. 
25.    //打印数据
26.   //printf("%s %d %f", s.c, s.i, s.f);
27.   fprintf(stdout,"%s %d %f", s.c, s.i, s.f);//使用fprintf函数把数据输出到标准屏幕，作用同上一句printf
28. 
29.   //关闭文件
30.   fclose(pf);
31.   pf = NULL;
32. 
33.   return 0;
34. }

ctrl+F5，查看运行结果：

fwirte

以二进制的形式把count个大小为size的数据写入到流中

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );//返回成功写入的元素个数

使用fwrite把数据块写入到流中：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. struct S
5. {
6.  char c[20];
7.  int i;
8.  float f;
9. };
10. 
11. int main()
12. {
13.   struct S s = { "abcdef",10,5.5f };
14.   //数据块进行写文件
15.   FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "w");//写入
16.   if (NULL == pf)
17.   {
18.     perror("fopen");
19.     return 1;
20.   }
21. 
22.   //写文件
23.   fwrite(&s, sizeof(struct S), 1, pf);
24. 
25.   //关闭文件
26.   fclose(pf);
27.   pf = NULL;
28. 
29.   return 0;
30. }

ctrl+F5，打开test.data文件，发现字符串以二进制的形式和以文本的形式写进去的内容是一样的，都是abcdef，整数和浮点数以二进制的形式和以文本的形式写进去的内容是不一样的：

fread

从流中读取count个大小为size的数据到buffer里面去

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );//返回成功读取的元素个数

使用fread从流中读取数据块

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. struct S
5. {
6.  char c[20];
7.  int i;
8.  float f;
9. };
10. 
11. int main()
12. {
13.   struct S s = { "abcdef",10,5.5f };
14.   //数据块进行写文件
15.   FILE* pf = fopen("C:\\Users\\Delia\\source\\repos\\bit4\\test.data", "r");//读取
16.   if (NULL == pf)
17.   {
18.     perror("fopen");
19.     return 1;
20.   }
21. 
22.   //读文件
23.   fread(&s, sizeof(struct S), 1, pf);
24.   printf("%s %d %f", s.c, s.i, s.f);
25. 
26.   //关闭文件
27.   fclose(pf);
28.   pf = NULL;
29. 
30.   return 0;
31. }

ctrl+F5运行，结果如下：

sprintf

把格式化数据写入到字符串

int sprintf ( char * str, const char * format, ... );//执行成功则返回写入的字符个数

sprintf和printf对比，sprintf比printf多了一个参数：字符串

sscanf

从字符串读取格式化数据

int sscanf ( const char * s, const char * format, ...);//返回成功读取的字符的个数

sscanf和scanf对比，sscanf比scanf多了一个参数：字符串

使用sprintf 先把一个格式化的数据，转换成字符串，再使用sscanf从字符串中还原出一个结构体数据

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. struct S
5. {
6.  char c[20];
7.  int i;
8.  float f;
9. };
10. 
11. int main()
12. {
13.   struct S s = { "abcdef",10,5.5f };
14.   struct S tmp = { 0 };
15. 
16.   char buf[100] = { 0 };
17. 
18.   //sprintf 把一个格式化的数据，转换成字符串
19.   sprintf(buf, "%s %d %f", s.c, s.i, s.f);
20.   printf("%s\n", buf);//以字符串形式打印
21. 
22.   //sscanf从字符串中还原出一个结构体数据
23.   sscanf(buf, "%s %d %f", tmp.c, &(tmp.i), &(tmp.f));
24.   printf("%s %d %f\n", tmp.c,tmp.i,tmp.f);
25. 
26.   return 0;
27. }

ctrl+F5运行，结果如下：

对比scanf/fscanf/sscanf 和 printf/fprintf/sprintf

文件的随机读写

文件指针在读文件时，定位文件内容不断发生变化，如果不想顺序读取呢？可以进行文件随机读写

fseek

根据文件指针的位置和偏移量来定位文件指针

int fseek ( FILE * stream, long int offset, int origin );//成功则返回0，否则返回非0

test.data中存放的是abcdef

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  FILE* pf = fopen("test.data", "r");
6.  if (pf == NULL)
7.  {
8.    perror("fopen");
9.    return 1;
10.   }
11. 
12.   //读取文件
13.   int ch = fgetc(pf);
14.   printf("%c\n", ch);//a
15. 
16.   //调整文件指针
17.   fseek(pf, 1, SEEK_CUR);//当前指针指向b，向后偏移一位，指向c
18. 
19.   ch = fgetc(pf);
20.   printf("%c\n", ch);//c
21. 
22.   fclose(pf);
23.   pf = NULL;
24.   return 0;
25. }

ctrl+F5运行，结果如下所示：

ftell

返回文件指针相对于起始位置的偏移量

long int ftell ( FILE * stream );//若成功则返回指针位置的值

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  FILE* pf = fopen("test.data", "r");
6.  if (pf == NULL)
7.  {
8.    perror("fopen");
9.    return 1;
10.   }
11. 
12.   //读取文件
13.   int ch = fgetc(pf);
14.   printf("%c\n", ch);//a
15. 
16.   ch = fgetc(pf);
17.   printf("%c\n", ch);//b
18. 
19.   ch = fgetc(pf);
20.   printf("%c\n", ch);//c
21. 
22.   //调整文件指针
23.   fseek(pf, -2, SEEK_CUR);
24. 
25.   ch = fgetc(pf);
26.   printf("%c\n", ch);//b
27. 
28.   //计算指针相对于起始位置的偏移
29.   int ret = ftell(pf);
30.   printf("%d\n", ret);
31. 
32.   fclose(pf);
33.   pf = NULL;
34.   return 0;
35. }

ctrl+F5运行，结果如下所示：

rewind

让文件指针的位置回到文件的起始位置

void rewind ( FILE * stream );

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  FILE* pf = fopen("test.data", "r");
6.  if (pf == NULL)
7.  {
8.    perror("fopen");
9.    return 1;
10.   }
11. 
12.   //读取文件
13.   int ch = fgetc(pf);
14.   printf("%c\n", ch);//a
15. 
16.   ch = fgetc(pf);
17.   printf("%c\n", ch);//b
18. 
19.   ch = fgetc(pf);
20.   printf("%c\n", ch);//c
21. 
22.   //调整文件指针
23.   fseek(pf, -2, SEEK_CUR);
24. 
25.   ch = fgetc(pf);
26.   printf("%c\n", ch);//b
27. 
28.   //计算指针相对于起始位置的偏移
29.   int ret = ftell(pf);
30.   printf("%d\n", ret);
31. 
32.   //让文件指针回到起始位置
33.   rewind(pf);
34.   ch = fgetc(pf);
35.   printf("%c\n", ch);//
36. 
37.   fclose(pf);
38.   pf = NULL;
39.   return 0;
40. }

ctrl+F5运行，结果如下所示：

文本文件和二进制文件

根据数据的组织形式，数据文件被称为文本文件或者二进制文件：数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件；如果要求在外存上以ASCII码的形式存储，则需要在存储前转换，以ASCII字符的形式存储的文件就是文本文件。

一个数据在内存中是怎么存储的呢？

字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节，31 30 30 30 30），而二进制形式输出，则在磁盘上只占4个字节（10 27 00 00）

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. int main()
4. {
5.  int a = 10000;
6.  FILE* pf = fopen("test.data", "wb");
7.  if (pf == NULL)
8.  {
9.    perror("fopen");
10.     return 1;
11.   }
12. 
13.   //写文件
14.   fwrite(&a, sizeof(int), 1, pf);
15.   return 0;
16. }

VS2019解决方案-源文件-添加-现有项，打开test.data文件

右击文件名-打开方式-二进制编辑器-确定

二进制打开文本文件：

文本读取结束的判定

feof

feof用于判断当文件读取结束的时候，是读取失败结束，还是遇到文件尾结束。

int feof ( FILE * stream );//返回非0则遇到文件尾结束，返回0则读取失败结束

所以使用feof时，文件一定读取结束了，因此不能用feof的返回值判断文件是否结束。

新建test1.data文本，向test.data里面存放的内容：

将test.data中的内容写入到test1.data中：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. 
4. int main()
5. {
6.  FILE* pfread = fopen("test.data", "r");
7.  if (pfread == NULL)
8.  {
9.    return 1;
10.   }
11.   FILE* pfwrite = fopen("test1.data", "w");
12.   if (pfread == NULL)
13.   {
14.     fclose(pfread);
15.     pfread = NULL;
16.     return 1;
17.   }
18. 
19.   //文件打开成功
20.   //读写文件
21.   int ch = 0;
22.   while ((ch = fgetc(pfread)) != EOF)
23.   {
24.     //写文件
25.     fputc(ch, pfwrite);
26.   }
27. 
28.   if (feof(pfread))
29.   {
30.     printf("遇到文件结束标志，文件正常结束\n");
31.   }
32.   else if(ferror(pfread))
33.   {
34.     printf("文件读取失败结束\n");
35.   }
36. 
37.   //关闭文件
38.   fclose(pfread);
39.   pfread = NULL;
40.   fclose(pfwrite);
41.   pfwrite = NULL;
42. 
43.   return 0;
44. }

ctrl+F5运行，结果如下：

且test.data的内容已经全部拷贝到test1.data中：

由此可以看出，feof返回非0，且遇到文件尾结束的。

文本文件读取结束和二进制文件读取结束的判断不同：

（1）文本文件读取是否结束，判断返回值是否为EOF(fgetc)，或NULL(fgets)。上面代码就是判断文本文件读取是否结束。

fgetc函数在读取结束的时候，会返回EOF；正常读取的时候，返回的是读取到的字符的ASCII码值。

fgets函数在读取结束的时候，会返回NULL，正常读取的时候，返回存放字符串的空间起始地址。

（2）二进制文件的读取结束判断，判断返回值是否小于实际要读的个数

fread函数在读取的时候，返回的是实际读取到的完整元素的个数。如果发现读取到的完整元素的个数小于指定的元素个数，这就是最后一次读取了。

文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理数据文件，缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。

下面代码可以证明缓冲区的存在：

1. #define  _CRT_SECURE_NO_WARNINGS  1
2. #include<stdio.h>
3. #include<windows.h>
4. int main()
5. {
6.  FILE* pf = fopen("test.data", "w");
7.  fputs("abcdef", pf);//先将代码放在输出缓冲区
8. 
9.  printf("睡眠10秒-已经写数据了，打开test.data文件，发现文件没有内容\n");
10.   Sleep(10000);
11. 
12.   printf("刷新缓冲区\n");
13.   fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件(磁盘)
14. 
15.   printf("再睡眠10秒-此时，再次打开test.data文件，文件有内容了\n");
16.   Sleep(10000);
17. 
18.   fclose(pf);
19.   //注：fclose在关闭文件的时候，也会刷新缓冲区
20.   pf = NULL;
21. 
22.   return 0;
23. }

ctrl+F5运行，打开test.data，文件为空

过10秒后，打开test.data，发现内容已经写入进去了，是从缓冲区写到文件的。

C语言-文件系统详解（三）

文件的顺序读写

fputc

fgetc

fputs

fgets

fprintf

fscanf

fwirte

fread

sprintf

sscanf

文件的随机读写

fseek

ftell

rewind

文本文件和二进制文件

文本读取结束的判定

feof

文件缓冲区

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C语言-文件系统详解（三）

文件的顺序读写

fputc

fgetc

fputs

fgets

fprintf

fscanf

fwirte

fread

sprintf

sscanf

文件的随机读写

fseek

ftell

rewind

文本文件和二进制文件

文本读取结束的判定

feof

文件缓冲区

热门文章

最新文章

相关课程

相关电子书