文件操作【fopen/fclose/fputs/fgets】【C语言/进阶】-阿里云开发者社区

1. 为什么要使用文件

打包数据，使我们能更高效地处理和使用数据。

注：C的函数有一个约定（不是绝对）：失败返回1，成功返回0

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");
fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
fclose(pf);
pf = NULL;
return 0;
}

4. 文件缓冲区

文件缓冲区就像一辆货车，当货车被填满后才会开始运送。

如果货车只要有货物就会运送，这很费油。

于是标准规定系统采用“缓冲文件系统”处理数据文件。

从内存向磁盘输出数据会先送到内存中的缓冲区，满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小由C编译系统决定。

5. 文件的打开和关闭

5.1 文件指针变量

介绍

每个被使用的文件都和一个在内存中对应的区域有着联系，称之为文件信息区，用来存放文件的相关信息（文件名、路径、状态等）。系统将这些信息用一个结构打包。该结构由系统声明，取名为FILE。

文件指针即指向FILE类型的指针变量

例

struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;//这些都是文件的信息
};
typedef struct _iobuf FILE;

不同编译器的FILE结构成员大同小异。

每当一个文件被打开时，系统会创建一个结构变量FILE，根据文件的情况更新其内容。这些底层的细节了解即可。

如何维护这个FILE结构？

使用一个指向FILE的指针变量，使之指向某文件的文件信息区（结构），通过信息访问文件。

FILE* pf;//pf是文件指针变量

综上，文件指针变量能找到它指向的文件

注意：文件信息区不是一个总的区域，它是随着文件联系在一起的

5.2 文件的打开和关闭

文件读和写，就和动态内存的开辟和释放一样，缺一不可，要一对一对地使用。

当通过程序打开文件，同时会返回一个FILE*地指针变量指向该文件，建立了指针和文件的关系。这就有点像打开一个信封，里面有信的内容，也有发件人的信息，通过这个信息，可以找到发件人。

标准规定使用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+”（读写）	打开一个二进制文件，在文件尾进行读和写	新建文件

重要的是前6个，最重要的是前三个

注意使用模式要匹配

用例

#include <stdio.h>
int main ()
{
FILE * pFile;//定义一个文件指针变量
//打开文件
pFile = fopen ("myfile.txt","w");//打开这个文件以写入
//一顿文件操作
.
.
.
//关闭文件
fclose (pFile);//只需传入一个参数
}
return 0;
}

6. 文件的顺序读写

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

“输入”和“输出”的对象是内存

输入：从文件读取数据到内存

输出：把内存的数据写入文件

关于“流”(stream)的概念

在生活中可能会听到“视频流”、“音频流”这些关于stream的词汇。这里的stream指的是字节流(Byte Stream)

对一台电脑的核心区域(磁盘、CPU等)来说，显示器、键盘等外接部件是设备。每个设备都需要从这个核心区域读取和写入数据，如果对每个设备都规定它要从某个具体区域读写数据，这未免也太麻烦了。不同的部件有自己需要的数据，就像一条河两边生活的人家一样，各取所需，各倒所弃，而这条stream里流的就是各种数据。

这是一个抽象的概念，需要在实践中理解它。

C程序会默认打开三个stream：

名称	stream	类型
标准输入流	stdin	FILE*
标准输出流	stdout	FILE*
标准错误流	stderr	FILE*

6.1 fputc

FILE * fopen ( const char * filename, const char * mode );

用例

#include<stdio.h>
int main()
{
  FILE* pf = fopen("test.txt", "w");//以写的形式打开文件
  //创建文件指针变量维护这个文件
  if (pf == NULL)//判断是否为空
  {
    perror("fopen");
    return 1;
  }
  fputc('a', pf);//将内容写入文件
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

注：这里将a字符写入文件是为了能直观地看到结果

体会fputc能向不同的流输出

下面将fputc的第二个参数改为标准输出流(stdout)，会发生什么呢？

#include<stdio.h>
int main()
{
  FILE* pf = fopen("test.txt", "w");
  if (pf == NULL)
  {
    perror("fopen");
    return 1;
  }
  fputc('a', stdout);//将内容写入标准输出流
  fclose(pf);
  pf = NULL;
  return 0;
}

6.2 fgetc

int fgetc ( FILE * stream );

从stream读取字符

用例

#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);
  fclose(pf);
  pf = NULL;
  return 0;
}

“不能走”的情况

读取到文件末尾的标志：EOF(End Of File)

如果文件为空，那么它读取的也为EOF，就像空字符串内容为\0一样

为什么返回值类型为int，不是读取一个字符(char)吗？这会不会有点浪费

函数本身就是读取字符，但在返回时将字符强转为int，那么就是字符的ASCII值，所以打印时以%c的形式打印就相当于抵消了强转。而设置强转的目的是返回错误信息EOF，它是一个宏，值为-1，如果以char返回-1这个值，会发生二进制位的截断，达不到返回错误信息的目的。

6.3 fputs

int fputs ( const char * str, FILE * stream );

将字符串写入stream

用例

#include<stdio.h>
int main()
{
  FILE* pf = fopen("test.txt", "w");
  if (pf == NULL)
  {
    perror("open file for writting");
    return 1;
  }
  fputs("hello\n", pf);
  fputs("new\n", pf);
  fputs("world\n", pf);
  fclose(pf);
  pf = NULL;
  return 0;
}

换行效果需要在写入时添加\n

不要忘了是以“w”的形式打开文件

6.4 fgets

char * fgets ( char * str, int num, FILE * stream );

从stream获取最多num个字符(包括\0)的字符串，该地址由str保存，所以其本质还是从stream读取字符

用例

#include<stdio.h>
int main()
{
  char input[20] = { 0 };
  FILE* pf = fopen("test.txt", "r");
  if (pf == NULL)
  {
    perror("open file for reading");
    return 1;
  }
  printf("%s\n", fgets(input, 20, pf));
  printf("%s\n", fgets(input, 20, pf));
  fclose(pf);
  pf = NULL;
  return 0;
}

为什么每打印一次就会多一个回车呢？

同样，这里依然有一个“位置”指针，每当函数读取成功，它就会往下走一步，当然单位是一个字符串(\0)

6.5 对比一组函数

scanf	fscanf	sscanf
printf	fprintf	sprintf

第一组我们再熟悉不过，这里重点讲第三组

我们在对数据操作时，对象往往不止前面那样，仅仅是一些字符，几个字符串，还有更复杂的数据类型，比如结构体变量。

6.5.1 sprintf

int sprintf ( char * str, const char * format, ... );

其功能是将数据格式化后写入字符串str

用例

#include<stdio.h>
struct Stu
{
  char name[20];
  int age;
  float score;
};
int main()
{
  struct Stu s= { "xioaming", 18, 99.2 };
  char str[100] = { 0 };
  sprintf(str, "%s %d %f", s.name, s.age, s.score);
  printf("%s", str);//直接以字符串的形式打印str
  return 0;
}

这样就相当于将不同类型的数据拼接为一个字符串，可以直接以字符串的形式打印

问：为什么打印socre的结果不是99.2？

6.5.2 sscanf

int sscanf ( const char * s, const char * format, ...);

其功能与sprintf相反

用例

#include<stdio.h>
struct Stu
{
  char name[20];
  int age;
  float score;
};
int main()
{
  struct Stu s= { "xioaming", 18, 99.2 };
  char str[100] = { 0 };
  struct Stu tmp = { 0 };//定义一个目的变量
  sprintf(str, "%s %d %f", s.name, s.age, s.score);
  //先写入
  //printf("%s", str);//直接以字符串的形式打印str
  sscanf(str, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
  //再转换
  printf("%s %d %f", tmp.name, tmp.age, tmp.score);
  //以结构的形式打印
  return 0;
}

综上：sscanf和sprintf是一对功能相反的函数

7. 文件的随机读写

上一节提到，当函数功能实现成功以后，有一个“位置”指针会往后走一步，单位由操作的数据类型决定。这时顺序读写。

随机读写就是在操作文件数据之前，决定被操作数据的位置。比如修改字符串中某个符号的值。

7.1 fseek

int fseek ( FILE * stream, long int offset, int origin );

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

origin是文件指针的位置；offset是一个宏，相对于该位置的偏移量

origin

常量	位置
SEEK_SET	文件开头
SEEK_CUR	文件指针的当前位置
SEEK_END	文件结束

用例

#include <stdio.h>
int main()
{
  FILE* pFile = fopen("test.txt", "wb");
  fputs("This is an apple.", pFile);
  fseek(pFile, 9, SEEK_SET);
  fputs(" sam", pFile);
  fclose(pFile);
  return 0;
}

7.2 ftell

long int ftell ( FILE * stream );

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

用例

#include<stdio.h>
int main()
{
  FILE* pf = fopen("test.txt", "w");
  if (pf == NULL)
  {
    return 1;
  }
  fputs("ABCDEF", pf);
  int ret = ftell(pf);
  printf("%d\n", ret);
  fclose(pf);
  pf = NULL;
  return 0;
}

7.3 rewind

void rewind ( FILE * stream );

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

用例

#include <stdio.h>
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);
  fread(buffer, 1, 26, pFile);
  fclose(pFile);
  buffer[26] = '\0';
  puts(buffer);
  return 0;

先把26个字母写入文件

然后从文件每次读一个，一个读26次，放在buffer中

*8. 文件读取结束的判定

8.1 被错误使用的feof函数

牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。

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

文本文件读取是否结束，判断返回值是否为EOF （ fgetc ），或者NULL （ fgets）
例如：
fgetc 判断是否为EOF .
fgets 判断返回值是否为NULL .

#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;//这是一个在stdlib的宏，值为1
  }
  //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);
}

二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
fread判断返回值是否小于实际要读的个数。

#include <stdio.h>
enum { SIZE = 5 };
int main(void)
{
  double a[SIZE] = { 1.0,2.0,3.0,4.0,5.0 };
  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);
}

更新日志

4/2/2022
Man9o

文件操作【fopen/fclose/fputs/fgets】【C语言/进阶】

1. 为什么要使用文件

2. 什么是文件

2.1 程序文件

2.2 数据文件

2.3 文件名

3. 文本文件和二进制文件

4. 文件缓冲区

5. 文件的打开和关闭

5.1 文件指针变量

5.2 文件的打开和关闭

6. 文件的顺序读写

6.1 fputc

6.2 fgetc

6.3 fputs

6.4 fgets

6.5 对比一组函数

6.5.1 sprintf

6.5.2 sscanf

7. 文件的随机读写

7.1 fseek

7.2 ftell

7.3 rewind

*8. 文件读取结束的判定

8.1 被错误使用的feof函数

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

文件操作【fopen/fclose/fputs/fgets】【C语言/进阶】

1. 为什么要使用文件

2. 什么是文件

2.1 程序文件

2.2 数据文件

2.3 文件名

3. 文本文件和二进制文件

4. 文件缓冲区

5. 文件的打开和关闭

5.1 文件指针变量

5.2 文件的打开和关闭

6. 文件的顺序读写

6.1 fputc

6.2 fgetc

6.3 fputs

6.4 fgets

6.5 对比一组函数

6.5.1 sprintf

6.5.2 sscanf

7. 文件的随机读写

7.1 fseek

7.2 ftell

7.3 rewind

*8. 文件读取结束的判定

8.1 被错误使用的feof函数

热门文章

最新文章

相关课程

相关电子书