目录

• 前言
• 什么是文件
• • 程序文件
  • 数据文件
• 文件指针
• • FILE结构的维护
• 文件的打开和关闭
• • 文件的打开方式
• 文件的顺序读写
• • fputc
  • fgetc
  • fputs
  • fgets
  • fprintf
  • fscanf
• 文件流 标准输入/输出流
• • sscanf和sprintf

前言

在讲文件操作之前，我们先来思考这个问题：
我们为什么要使用文件呢？
我们前面写过通讯录，但是我们发现，我们往通讯录中添加联系人后，一旦关掉程序，我们添加的联系人就都没有了，又要重新输入，这样的通讯录使用起来就很不方便。
那么，
我们怎么样做才能让数据持久化呢？
我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

什么是文件

在程序设计中，我们一般谈的文件有两种：程序文件（源文件）、数据文件（从文件功能的角度来分类的）

程序文件

包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。

数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。

这两者的关系我们以通讯录为例来联系起来，如图1

那么，文件的输入输出操作该怎么实现呢？

文件指针

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名
字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统
声明的，取名FILE.
在vs2013环境下的声明如下

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结构的变量。

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

定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

文件的打开和关闭

在学习输入和输出之前，我们首先要先学习如何打开和关闭文件。

ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件。
这两个函数的书写格式分别如下

//打开文件
FILE * fopen ( const char * filename, const char * mode );

filename指的是文件名，mode指的是打开方式

文件的打开方式

打开方式如图2

我们现在来举个例子（以读的方式打开test.txt文件）

#include <stdio.h>

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

如果我们当前项目下有test.txt文件，那么程序就运行成功了，如图3

上面代码中的test.txt是相对路径<>/font，即只能在当前这个项目里找文件如果我们想打开桌面上的文件,就要写入对应的文件路径，这个路径我们可以在文件的属性中查找，过程如图4

代码如下

int main()
{
	//打开文件
	FILE* pf = fopen("C:\\Users\\张思诚\\Desktop\\test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

注意！这里的\代表的是转义字符，我们想让它老老实实的让它保持它原来的意思，我么再加一个\，将转义字符转义，这样\就表示原来的意思了。

如果桌面上本来没有这个文件，就会在桌面上新生成一个test.txt文件。
如果文件存在，它会把文件内容彻底销毁掉。

文件的顺序读写

文件的读写功能有如下几种

那么这些函数具体怎么使用呢？

fputc

以fputc为例，假设我们要在文件里输入26个字符。
fputc的参数如下

int fputc ( int character, FILE * stream );

代码如下

int main()
{
	//打开文件
	FILE* pf = fopen("C:\\Users\\张思诚\\Desktop\\test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	int i = 0;
	for (i = 0; i < 26; i++)
	{
		fputc('a' + i, pf);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

运行结果如图5

fgetc

我们再来试试读文件（fgetc）
fgetc的参数如下

int fgetc ( FILE * stream );

还需注意的是，如果读取失败，会返回EOF，即-1,如果读取成功，读取之后stream会自动前进到下一个字符的位置，fgets函数的返回值是整型，其实就是 ascll码值。.

int main()
{
	//打开文件
	FILE* pf = fopen("C:\\Users\\张思诚\\Desktop\\test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	int ch = 0;
	int i = 0;
	for (i = 0; i < 26; i++)
	{
		ch = fgetc(pf);
		printf("%c ", ch);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

运行结果如图6

fputs

我们再来看输入一行内容的函数。
fputs函数的参数如下：

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

代码如下：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写一行数据 “hello world”
	fputs("hello world\n", pf);
	fputs("你好\n",pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

代码运行结果如图7

fgets

我们再来看读一行数据的函数fgets
函数书写格式如下：

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

fgets函数在读取数据时，只能读到num-1个数据，因为最后一位要留来存放**\0**。
注意别忘了打开方式改为r。
代码实现如下

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读一行数据 “hello world”
	char arr[20];
	fgets(arr, 5, pf);
	printf("%s", arr);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

打印结果如图8

所以要想打印出hello，num的值就应该为6。

下面我们来介绍格式化读写函数。

fprintf

我们先来看fprintf的函数参数

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

fprintf的函数参数我们可以类比printf的函数参数。
printf的函数参数如下

int printf ( const char * format, ... );

假设我们要打印一个结构体，代码如下

struct S
{
	int n;
	float f;
	char arr[20];
};
int main()
{
	struct S s = { 100,3.14,"zhangsan" };
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
    fprintf(pf, "%d %f %s", s.n, s.f, s.arr);
	
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

我们在test这个文件中可以看到打印的结果，如图10

fscanf

还是先来看fscanf的函数参数

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

我们还是可以类比scanf的函数参数

int scanf ( const char * format, ... );

假设我们要从上面文件中读取数据，代码如下

struct S
{
	int n;
	float f;
	char arr[20];
};
int main()
{
	struct S s = { 0 };
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	fscanf(pf, "%d %f %s", &(s.n), &(s.f), &(s.arr));
	
	printf("%d %f %s", s.n, s.f, s.arr);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

在显示器上打印结果如下：

文件流 标准输入/输出流

在前面的表格宏我们知道，以上介绍的这六种函数能适用于所有输入或输出流的，那么流的概念是什么呢？
1文件流：顾名思义，我们在读写文件的时候，操作的就是文件流，如上面提到的test.txt等。
2，标准输出流：对应的是终端设备–屏幕，即在屏幕上来进行读取。用stdin来表示。
3，标准输入流： 对应的是终端设备–键盘，即通过键盘来进行书写，用stdout来表示。

我们就以在终端输入和打印一个结构体为例，代码如下

struct S
{
	int n;
	float f;
	char arr[20];
};
int main()
{
	struct S s = {0};
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//
	
	fscanf(stdin, "%d %f %s", &(s.n), &(s.f), s.arr);
	fprintf(stdout,"%d %f %s", s.n, s.f, s.arr);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

在终端上输入和打印结果如图12

sscanf和sprintf

我们先来看是sprintf的参数

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

这个函数的功能实现在于将格式化的数据以字符串的形式存入缓冲区。
而sscanf的参数如下

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

这个函数的功能就和ssprintf是相反的，是将字符串转换为格式化的数据。
举个例子

struct S
{
	int n;
	float f;
	char arr[20];
};
int main()
{
	struct S s = {123,3.14,"www"};
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//将结构体数据转换成字符串
	char arr[200] = { 0 };
	sprintf(arr, "%d %f %s", s.n, s.f, s.arr);
	printf("字符串的数据：%s\n", arr);

	//将字符串转化为对应的格式化数据
	struct S tmp = { 0 };
	sscanf(arr, "%d %f %s", &(tmp.n), &(tmp.f), tmp.arr);
	printf("格式化的数据：%d %f %s", tmp.n, tmp.f, tmp.arr);
	
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

在屏幕上打印结果如下

以上就是本章节全部内容，如有出入，欢迎大佬指正。