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 指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联 的文件 。

例如：

4.2文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。
ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件

//打开文件
FILE *fopen( const char *filename, const char *mode )
//关闭文件
int fclose( FILE *stream )

?filename可以加上文件路径，但是别忘了要对\进行转义，防止被认为是转义字符
stream表示流，是一个抽象概念，它与外部设备（键盘，屏幕，u盘，硬盘，网卡......）相关联，例如我们需要写数据就写到流里，拿数据就从流中拿，?而流又包括很多种，有文件流（用于读写文件）

还有

（只要一个c程序运行起来，这三个流就是默认打开的）

标准输入流? ?stdin? --》键盘
标准输出流? ?stdout? --》屏幕? ? //都是FILE*类型
标准错误流? ?stderr? --》屏幕

绝对路径：是从盘符开始的路径?，例如：C:\2022code\vs2019\test4_13\1.jpg
相对路径：指的是当前文件资源所在的目录的路径, 则上面的相对路径就是1.jpg,严格的写法是.\1.jpg
在描述相对路径时，.\代表当前路径，..\代表上一级路径

打开方式（mode）：

文件使用方式	含义	如果指定文件不存在
“r” （只读）	为了输入数据，打开一个已经存在的文本文件	出错
“w” （只写）	为了输出数据，打开一个文本文件	建立一个新的文件
“a” （追加）	向文本文件尾添加数据	建立一个新的文件
“rb” （只读）	为了输入数据，打开一个二进制文件	出错
“wb” （只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
“ab” （追加）	向一个二进制文件尾添加数据	出错
“r+” （读写）	为了读和写，打开一个文本文件	出错
“w+” （读写）	为了读和写，建议一个新的文件	建立一个新的文件
“a+” （读写）	打开一个文件，在文件尾进行读写	建立一个新的文件
“rb+” （读写）	为了读和写打开一个二进制文件	出错
“wb+” （读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
“ab+” （读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件

举个例子：
?

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");//注意看电脑文件扩展名有没有露出来
	//可以打开其他路径的文件
	if (NULL ==pf)
	{
		perror("fopen");
		return;
	}
	//读文件
	//关闭文件
	//fclose(NULL);//fclose不可以传NULL,error
	//写文件
	int ch = 0;
	while ((ch = fgetc(pf) != EOF))//读取的是字符，字符串末尾是\0
	{
		printf("%c ", ch);
	}
	fclose(pf);//和free的用法差不多
	pf = NULL;
	return 0;
}

这里要注意：1.fclose（）不能传空指针，会报错

?2.在打开文件前，应查看路径下的文件扩展名有没有打开，防止出错。

5. 文件的顺序读写

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

下面函数的对象都是文件?

??5.1fput函数（将字符放（put）到文件中）

int fputc( int c, FILE *stream );?

c为字符

注意：写入的时候用的是mode为w?


int main()
{
	FILE* pf = fopen("test.txt", "w");// w 表示只写入数据存到文本文件中
	if (NULL ==pf)
	{
		perror("fopen");
		return;
	}
	//写文件
	char ch = 'a';
	for (ch = 'a';ch <= 'z';ch++)//将字符a~z存到文件中
	{
		fputc(ch, pf);
	}
	//int ch = 0;
	//while ((ch = fgetc(pf) != EOF))//读取的是字符，字符串末尾是\0
	//{
	//	printf("%c ", ch);
	//}
	fclose(pf);
	pf = NULL;
	return 0;
}

放完数据后我们再用fgetc进行读取?

5.2fgetc函数(从文件中获取(get)字符）

int fgetc( FILE *stream );

?返回读到的字符的ascaII码值
当文件结束或者遇到错误时返回EOF

注意：读取的时候用的是mode为r?

int main()
{
	FILE* pf = fopen("test.txt", "r");// r 表示只读取数据存到文本文件中
	if (NULL ==pf)
	{
		perror("fopen");
		return;
	}
	//写文件
	//char ch = 'a';
	//for (ch = 'a';ch <= 'z';ch++)//将字符a~z存到文件中
	//{
	//	fputc(ch, pf);
	//}
	int ch = 0;
	while ((ch = fgetc(pf) != EOF))//读取的是字符，字符串末尾是\0
	{
		printf("%c ", ch);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

fputc和fgetc适用于所有输入输出流
int main()
{
?? ?int ch = fgetc(stdin);//也可以直接在键盘上读取
?? ?//printf("%c\n",ch);
?? ?fputc(ch, stdout);//可以在键盘上输入的数据直接放到文件中
?? ?return 0;
}??

?5.3fputs函数（将字符串放到（put）文件中）

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

int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (NULL ==pf)
	{
		perror("fopen");
		return;
	}
	//以写的形式打开文件会销毁原来的内容，重新输入（覆盖）
	fputs("qwertyuiop\n",pf);//这里可以在字符串后面加上换行操作
	fputs("xxxxxxxxxx\n", pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

?5.4fgets函数(从文件中获取(get)字符串）

char *fgets( char *string, int n, FILE *stream );

?string为字符串

?n为读取字符的最大数量

int main()
{
	char arr[256] = { 0 };
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return;
	}
	//读一行
	//fgets(arr,256,pf);//这里最多读255个字符，有一个留给‘\0'
	//printf("%s", arr);
	//在不知道文件中有多少字符时
	while (fgets(arr, 256, pf) != NULL)
	{
		printf("%s", arr);
	}
	fclose(pf);//和free的用法差不多
	pf = NULL;
	return 0;
}

?5.5fprintf函数（以格式化的形式将数据放到文件中）

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

可能不太好理解

我们先类比一下我们学过的printf函数

int printf( const char *format [, argument]... );

发现只需要多传入一个指向文件的指针，其余用法相同。

struct s
{
	char name[20];
	int age;
	int score;
};
//格式化输出函数fprintf->可以将结构体等一些变量格式化放到文件里
int main()
{
	struct s s = { "李四",18,100 };
	FILE* pf = fopen("test2.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fprintf(pf, "%s %d %d", s.name, s.age, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

5.6 fscanf函数（从文件中获取格式化的数据）

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

我们这也类比一下scanf函数，方便理解

int scanf( const char *format [,argument]... );

//fscanf函数
//格式化输入函数fscanf->可以将文件中结构体等一些信息格式化放到变量中
struct s
{
	char name[20];
	int age;
	int score;
};
int main()
{
	struct s s = { 0 };
	FILE* pf = fopen("test2.txt", "r");//读取打开文件的信息
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	fscanf(pf, "%s %d %d", s.name, &(s.age), &(s.score));
	//打印在屏幕上
	//printf("%s %d %d", s.name,s.age, s.score);
	fprintf(stdout,"%s %d %d", s.name, s.age, s.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

5.7了解sprintf和sscanf?

1.sprintf函数（将格式化的数据写入到一个字符串中）

int sprintf( char *buffer, const char *format [, argument] ... );

?buffer为存放字符串的指针，其余用法和printf函数相同

struct s
{
	char name[20];
	int age;
	int score;
};

int main()
{
	char buf[256] = { 0 };
	struct s s = { "lisi",18,95 };
	sprintf(buf, "%s %d %d", s.name, s.age, s.score);
	printf("%s\n", buf);
	return 0;
}

2.sscanf函数?（从一个字符串中读取一段格式化数据）

int sscanf( const char *buffer, const char *format [, argument ] ... );

buffer为存放字符串的指针，其余用法和scanf函数相同

struct s
{
	char name[20];
	int age;
	int score;
};
int main()
{
	char buff[256] = { 0 };
	struct s s2 = { "lisi",18,95 };
	struct s s1 = { 0 };
	//sprintf(buff, "%s %d %d", s2.name, s2.age, s2.score);
	//printf("%s\n", buff);
	//从buf字符串中提取结构体数据
	sscanf(buff, "%s %d %d", s1.name, &(s1.age), &(s1.score));
	printf("%s %d %d", s1.name, s1.age, s1.score);
	return 0;
}

scanf / printf? ? ? ?

是针对标准输入流 / 标准输出流的格式化输入 / 输出语句。

fscanf / fprintf? ?

是针对所有输入流 / 所有输出流的格式化输入输出语句，包含上面函数的功能。

sscanf / sprintf? ?

sscanf是从字符串中读取格式化的数据，sprintf是把格式化的数据输出成（存储到）字符串。