前言：上一篇我们介绍了文件的基本内用以及文件的打开（fopen）和关闭（fclose）

本篇我们来介绍文件的顺序读写，以及相关函数的对比

文件的顺序读写

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

函数介绍：

fputc字符输出函数

fputc

int fputc ( int character, FILE * stream );
//FILE * stream文件流（文件指针指向的数据），int character输出的字符

示例：

int main()
{
  //打开文件
  //相对路径，文件在运行程序的路径下打开
  FILE* pf = fopen("test.txt", "w");//w打开方式为只写，需要注意的是这里是双引号
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //写文件
  fputc('a', pf);
  fputc('b', pf);
  fputc('c', pf);
  int i = 0;
  for (i = 0; i < 26; i++)
  {
    fputc('a'+i, pf);
  }
  //关闭文件
  fclose(pf);//
  pf == NULL;
  return 0;
}

上面代码运行后我们打开出现的test.txt文件

文件内容：

fgetc字符输入函数

fgetc

int fgetc ( FILE * stream );

返回指定流的内部文件位置指示符当前指向的字符。然后，内部文件位置指示器将前进到下一个字符。
如果调用时流位于文件末尾，则该函数返回EOF。
如果发生读取错误，该函数将返回EOF并为流设置err指针。

int main()
{
  //打开文件
  //相对路径，文件在运行程序的路径下打开
  FILE* pf = fopen("test.txt", "r");//r只读
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //读文件//多次读取，结果会向后偏移
  int i = 0;
  for (i = 0; i < 26; i++)
  {
    int ch = fgetc(pf);
    printf("%c", ch);
  } 
  //关闭文件
  fclose(pf);//
  pf == NULL;
  return 0;
}

读出结果：

因为调用时流如果位于文件末尾，则该函数返回EOF。

所以我们可以对代码中读文件的循环操作进行改进，改进后可以直接将文件中的内容全部读取出来。

这里为方便大家复制代码，将改进后代码给出：

int main()
{
  //打开文件
  //相对路径，文件在运行程序的路径下打开
  FILE* pf = fopen("test.txt", "r");//r只读
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //读文件//多次读取，结果会向后偏移
  //int i = 0;
  //for (i = 0; i < 26; i++)
  //{
  //  int ch = fgetc(pf);
  //  printf("%c", ch);
  //}
  //改进
  int ch = 0;
  while ((ch = fgetc(pf)) != EOF)
  {
    printf("%c ", ch);
  }
  //关闭文件
  fclose(pf);//
  pf == NULL;
  return 0;
}

运行结果：

可以看到我们将文件中的内容全部打印了出来。

注意：如果进行多次读取，得到的结果会向后偏移

fputs文本行输出函数

fputs

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

示例：

#include<stdio.h>
int main()
{
  //打开文件
  FILE* pf = fopen("test.txt", "w");
  if (NULL == pf)
  {
    perror("fopen");
      return 1;
  }
  //写文件 一行一行写
  fputs("xiaowei", pf);//如果想要换行需要在字符串中输入\n
  printf("\n");
    fputs("@T", pf);
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

大概大家也注意到了换行的问题，不能用printf（“\n”）;

因为在换行时只关注内容，

所以想要换行需要在字符串中输入\n，这时可以认为\n就是内容中的一部分。

将代码中写文件的部分改为如下：

//写文件 一行一行写
  fputs("xiaowei\n", pf);
  fputs("@T", pf);

文件内容：

这就很好地实现了换行。

fgets文本行输入函数

fgets

fgets读取内容时会将终止符\0认为是其中的内容，实际读取的是num-1个元素，剩下一个为\0。
若文本中有换行，读取时会自动认为换行符\n是其中的内容，并将其读取。
下一次读取会从之前读取结束的位置开始
如果读取正常，返回的是存放读取到的数据的地址
如果读取失败，返回NULL

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

示例：

//按照顺序读取文本行
// fgets
//读到的内容将被放到指针str指向的字符数组中
//num要复制到str 的最大字符数（包括终止空字符），真正读到的字符是num-1个
int main()
{
  //打开文件
  FILE* pf = fopen("test.txt", "r");
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //读取文件一行一行读
  char arr[] = "##############";
  fgets(arr, 5, pf);
    printf{"%s",arr};
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

运行监视：

代码中我们给到的num的值为5，而这5个里包含\0,实际读到的内容是num-1个字符

当我们将代码中的5，改为15时，监视如下：

此时，我们发现增加了num的值，却没有读到下一行的内容，而是读取了\n和\0。

总结：

fgets读取内容时会将终止符\0认为是其中的内容，实际读取的是num-1个元素，剩下一个为\0。

若文本中有换行，读取时会自动认为换行符\n是其中的内容，并将其读取。

如何进行换行？

如上我们只需进行二次读，就可以将下一行读出，在进行第二次读取时会从第一次读取后面的位置开始。

为了方便大家复制，代码给出：

int main()
{
  //打开文件
  FILE* pf = fopen("test.txt", "r");
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //读取文件一行一行读
  char arr[] = "##############";
  fgets(arr, 15, pf);
  printf("%s", arr);
  fgets(arr, 15, pf);
  printf("%s", arr);
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

fprintf格式化输出函数

fprintf

int fprintf ( FILE * stream, const char * format, ... );

观察上面fprintf和printf的定义，我们发现非常相似，仅仅相差一个FILE*steam。

示例：

//写一个结构体的数据
struct S
{
  char name[20];
  int age;
  float score;
};
int main()
{
  struct S s = { "zhangsan",20,95.5f };
  //把s中的数据写到文件中
  FILE* pf = fopen("test.txt", "a");//a是打开方式，追加
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //写文件--fprintf,与printf类似
  fprintf(pf, "%s %d %f", s.name, s.age, s.score);
  fclose(pf);
  pf = NULL;
  return 0;
}

执行后文件内容：

fscanf格式化输入函数

fscanf

int fscanf ( FILE * stream, const char * format, ... );

format是格式，data是数据

从文件流以一定的格式读取数据

如果读取正常，返回的是格式串中指定的数据的个数

如果读取失败，返回的是小于格式串中指定的数据的个数

struct S
{
  char name[20];
  int age;
  float score;
};
int main()
{
  struct S s = { "zhangsan",20,95.5f };
  //把s中的数据写到文件中
  FILE* pf = fopen("test.txt", "r");
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //读文件--fscanf,与scanf类似
  fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));//将内容写到文件中
  printf("%s %d %f\n", s.name,s.age, s.score);//将文件中的内容读到屏幕上
  fclose(pf);
  pf = NULL;
  return 0;
}

输出结果如下：

文件操作函数作用于终端：

如上图，我们看到屏幕对应的是标准输出流，文件对应的是输出流，而下面的六个函数分别对应的是所有输入输出流。

那么我们对于文件操作的函数是否可以作用于屏幕呢？答案是可以的！

对键盘和屏幕操作不像文件一样有打开和关闭的操作，

对任何一个c程序，只要运行起来就默认打开三个流

stdin - 标准输入流 - 键盘

stdout - 标准输出流 - 屏幕

stderr - 标准错误流 - 屏幕

这三个流的类型是FILE*类型的，就有一个FILE*的指针与流对应

那么当从键盘输入数据时就传stdin ，当从屏幕输出数据的时候就传stdout。

示例：

//scanf(……);
//fscanf（stdin,……);
//printf(……);
//fprintf(stdout,……);
int main()
{
  int ch = fgetc(stdin);
  fputc(ch,stdout);
  return 0;
}

运行：这里我们输入q，屏幕上又打印出一个q

fwrite二进制输出函数

fwrite

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

void *ptr指针指向的是要被写入的数据元素

size_t size每一个要被写的元素的大小

size_t count 写入元素的数量

FILE*stream目标文件

fread二进制输入函数

fread

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

size_t size每一个要被读的元素的大小

size_t count 读取元素的数量

FILE*stream被读取的文件

示例：

//二进制输出函数fwrite
struct S
{
  char name[20];
  int age;
  float score;
};
int main()
{
  struct S s = { "zhangsan",20, 95.5f };
  //把s中的数据写到文件中
  FILE* pf = fopen("test.txt", "wb");//"wb"是以二进制形式写
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //写文件
  fwrite(&s,sizeof(s),1,pf);
  fclose(pf);
  pf = NULL;
  return 0;
}

这时写到文件里的内容如下：

因为是二进制形式的所以我们无法分辨，那就需要将用机器将其识别后打印到屏幕上方便我们识别，

//二进制输入函数fread
struct S
{
  char name[20];
  int age;
  float score;
};
int main()
{
  struct S s = { 0 };
  //把s中的数据写到文件中
  FILE* pf = fopen("test.txt", "rb");//"rb"是以二进制形式读
  if (NULL == pf)
  {
    perror("fopen");
    return 1;
  }
  //读文件
  fread(&s, sizeof(s), 1, pf);
  printf("%s %d %f\n", s.name, s.age, s.score);
  fclose(pf);
  pf = NULL;
  return 0;
}

下面是识别二进制后打印到屏幕上的内容：

对比一组函数：

scanf/fscanf/sscanf

printf/fprintf/sprintf

答案如下：

定义对比：

sscanf和sprintf函数的使用

struct S
{
  char name[10];
  int age;
  float score;
};
int main()
{
  char buf[100] = { 0 };
  struct S tmp = { 0 };
  struct S s = { "zhangsan",20,95.5f };
  //能够把这个结构体的数据，转换成字符串
  //"zhangsan 20 95.5"
  sprintf(buf, "%s %d %f", s.name, s.age, s.score);//将结构体数据以指定的格式转换成字符串
  printf("%s\n", buf);//以字符串的形式打印结构体
  //能否将buf中的字符串，还原成一个结构体数据呢？
  sscanf(buf,"%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
  printf("%s %d %f", tmp.name, tmp.age, tmp.score);//以结构体的形式打印字符串
  return 0;
}

应用场景：

结语：

这里我们关于前半部分的内容就介绍完了，后半部分马上会更，下一篇我们介绍如下内容：

文件的随机读写

文本文件和二进制文件

文件读取结束的判定

文件缓冲区

文章中某些内容我们之前有介绍，所以只是一笔带过，还请谅解。
希望以上内容对大家有所帮助👀，如有不足望指出🙏

前路漫漫，加油！！

【C】语言文件操作（二）