【进阶C语言】C语言文件操作

1. 为什么使用文件
2. 什么是文件
3. 文件的打开和关闭
4. 文件的顺序读写
5. 文件的随机读写
6. 文本文件和二进制文件
7. 文件读取结束的判定
8. 文件缓冲区

一、文件与文件的意义

1.文件的意义

文件的意义，无非就是为什么要使用文件？

（1）前面学习写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数
据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受

（2）使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

2.文件的定义

（1）文件分类

从文件功能的角度分类：程序文件和数据文件（本节论述的对象）

（1）程序文件：包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe），也就是我们写代码生成的文件。

（2）数据文件：文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。用来提供数据或者存储数据

如：用函数操作文件（打开、输出等等操作），该文件就是数据文件。并且本节内容讨论的都是数据文件

关系：

（2）文件名

文件名就是文件的一个名字，一个文件要有一个唯一的文件标识，以便用户识别和引用。

文件名包括三个部分：文件路径+文件名主干+文件后缀

如： c:\code\test.txt

c:\code\：表示文件路径 test：表示文件名主干 .txt：表示文件后缀

二、文件的打开与关闭

1.文件指针

定义：

（1）“文件类型指针”，简称“文件指针”。

为什么会有文件指针：

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名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* pf;//文件指针变量

关于文件打开的知识：

每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，该变量就指向了文件信息区，通过该指针就可以找到文件。使用者不必关心细节。

所以我们需要创造一个文件指针变量来接收打开文件后返回的变量，该指针变量就可以访问该文件。

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

图示：

2.文件的打开与关闭

（1）意义：文件在读写之前应该先打开文件，在使用结束之后应该关闭文件

（2）在标准C中规定：使用fopen函数来打开文件，fclose来关闭文件。

（3）fopen：

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

函数解析：

文件的打开方式：

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

如：

FILE* pf = fopen("data.txt", "r");

（4）fcolse：

//关闭文件
int fclose ( FILE * stream );

函数解析：

（5）打开与关闭

目的：在当前路径以“r”的形式打开：data.txt的文档

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fclose(pf);//关闭文件
	pf == NULL;//将指针置空
	return 0;
}

运行结果：

表示当前文件不存在或者找不到

当前路径的文件：

添加该（文本）文档后：

结果：

（6）文件打开的两种路径：相对路径和绝对路径

如：需要打开的文档在上一层路径

相对路径：

运行结果：

修改代码：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("..\\data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fclose(pf);
	pf == NULL;
	return 0;
}

相对路径解析：

（1）.\\：表示当前路径，不写则默认当前路径

（2）..\\：表示上一层路径。（\\为转义符号，转义后为一个\）

绝对路径：

第一步：找到该文档的路径

第二步：打开文件

#include<stdio.h>
int main()
{
	FILE* pf = fopen("C:\\gitee代码\\first-warehouse\\data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fclose(pf);
	pf == NULL;
	return 0;
}

运行结果：

程序与文件的关系：

三、文件的读写

前面论述了文件的打开与关闭，接下来就是对文件的读写操作了

顺序读写

在顺序读写中，需要用到以下的函数：

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

输入流：文件-->程序输出流：程序-->文件

大致分类：

（1）字符输入/输出函数：针对字符

（2）文本行输入/输出函数：针对一行数据，如字符串

（3）格式化输入/输出函数：格式化数据，如整形、浮点型

1-3操作的都是文本文件

（4）二进制输入/输出函数：二进制的文件

介绍流的概念：

原因：我们写好的程序（数据）想要输出某个位置（如下图），每个位置的输出方式都不一样，为了统一，我们引入了流的概念。

总结：流就是程序与系统之间的一个通道

为了方便程序员的操作，引入了流：每一个流的类型都是FILE*

我们只需要负责将数据引入流即可，流再负责存入外部设备上。

C语言程序：

C语言程序运行起来，就会自动打开三个流：

1.标准输入流stdin 2.标准输出流stdout 3.标准错误流stderr

这三个流的类型也都是FILE*

如：

（1）scanf函数（从键盘读取数据），会自动打开标准输入流

（2）printf函数（像屏幕打印数据），会自动打开标准输出流

文件：我们操作文件时，流不会自动打开，需要我们自己动手

我们打开文件和关闭文件的操作，相当于打开了一个流。

1.fputc函数

（1）这是输出字符函数，意思是将字符写入文件中，也就是写文件操作。

（2）该函数使用于所有输出流，也可以直接将信息输出到屏幕上。

例子1：输入26字母到文档中

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.写文件
	char ch = 0;
	for (ch = 'a'; ch <= 'z'; ch++)
	{
		if (ch % 5 == 0)
		fputc('\n', pf);
		fputc(ch, pf);
	}
	//3.关闭文件
	fclose(pf);
	pf == NULL;
	return 0;
}

结果：

在输出的时候（写文件），有一个文件状态指针（类似光标）指向该文档，每写入一个文件，该指针就会指向下一个位置。（并不是pf指针）

例子2：利用输出流直接将数据输出到屏幕上

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//2.输出流
	char ch = 0;
	for (ch = 'a'; ch <= 'z'; ch++)
	{
		if (ch % 5 == 0)
			fputc('\n', stdout);
		fputc(ch, stdout);
	}
	//3.关闭文件
	fclose(pf);
	pf == NULL;
	return 0;
}

运行结果：

2.fgetc函数

字符输入函数，用来将文件中的数据输入到程序中，称为读文件

（1）读取成功，返回该字符的ASCII值

（2）读取失败，返回EOF，并在流上设置一个错误标记，可用perror检测

例子：写一个程序读取文档中的数据并输出到屏幕上

（1）

（2）启动程序

#include<stdio.h>
int main()
{
	//1.打开文件（以只读的形式）
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.读文件
	int ch = 0;
	while ((ch = fgetc(pf))!=EOF)
	{
		printf("%c",ch);//输出到屏幕上
	}
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

结果展示：

3.fputs函数

例子1：程序输出到文档中

#include<stdio.h>
int main()
{
	//1.打开文件(不存在则创造文件)
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.写文件
	fputs("love\n",pf);
	fputs("you\n",pf);
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

文档结果：

例子2：数据输出到屏幕上

#include<stdio.h>
int main()
{
	//1.打开文件(不存在则创造文件)
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.写文件
	fputs("love\n",stdout);
	fputs("you\n",stdout);
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

结果：

4.fgets函数

读取数据的条件：

（1）遇到\n停止，只会读取一行的数据4

（2）只会读取num-1个数据

例子1：读取超过原有数据的个数

文档内容：

代码：

#include<stdio.h>
int main()
{
	//1.打开文件(不存在则创造文件)
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.读文件
	int arr[100] = { 0 };//存放读取到的数据
	fgets(arr,100,pf);
	printf("%s\n",arr);

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

运行结果：

遇到\n停止了读取

例子2：读取少于数据个数

#include<stdio.h>
int main()
{
	//1.打开文件(不存在则创造文件)
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.读文件
	int arr[100] = { 0 };//存放读取到的数据
	fgets(arr,3,pf);
	printf("%s\n",arr);

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

运行结果：

5.fprintf函数

用来把多种格式的数据输出到文件中

例子：

#include<stdio.h>
struct Stu
{
	float f;
	char c;
	int a;
};
int main()
{
	struct Stu s = {5.20,'a',1314};
	//1.打开文件
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.写文件
	fprintf(pf,"%.2f-%c-%d",s.f,s.c,s.a);
	
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

存入文档后：

6.fscanf函数

例子：从上面的文档中输入，并打印到屏幕上

#include<stdio.h>
struct Stu
{
	float f;
	char c;
	int a;
};
int main()
{
	struct Stu s = {0};
	//1.打开文件
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.读文件
	fscanf(pf, "%f-%c-%d", &(s.f), &(s.c), &(s.a));
	printf("%.2f-%c-%d\n", s.f, s.c, s.a);
	
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

结果：

以下函数针对二进制的文件

7.fwrite函数

将ptr中的内容输出到流所指向的文件中。

#include<stdio.h>
int main()
{
	int arr[5] = {1,2,3,4,5};
	//1.打开文件
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.读文件
	fwrite(arr,sizeof(arr[0]),sizeof(arr)/sizeof(arr[0]),pf);
	
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

文件中的内容：

这是二进制文件，肉眼无法看懂，所以我们可以再用二进制函数输出即可

8.fread函数

返回值解析：fread要求读取count个大小为size大小的数据

（1）真是读取到了count个数据，则返回count

（2）没用读取到count个数据，返回的是真实读取到的完整数据个数

我们读取上面的二进制文件并且打印出来

#include<stdio.h>
int main()
{
	int arr[5] = {0};
	//1.打开文件
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//2.读文件
	fread(arr,sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
	int i = 0;
	for (i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}
	//3.关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

结果：

9.sscanf函数与sprintf函数

sscanf函数：将字符串转换成格式化的数据

sprintf函数：将格式化的数据转换成字符串

sprintf单独使用：

#include<stdio.h>
struct Stu
{
	float f;
	char c;
	int a;
};
int main()
{
	struct Stu s = {5.20,'a',520};
	int arr[20] = { 0 };//存放转换后的字符串
	sprintf(arr,"%.2f-%c-%d",s.f,s.c,s.a);
	printf("%s\n",arr);
	return 0;
}

结果：

配合sscanf函数转回格式化的数据：

#include<stdio.h>
struct Stu
{
	float f;
	char c;
	int a;
};
int main()
{
	struct Stu s = {5.20,'a',520};
	int arr[20] = { 0 };//存放转换后的字符串
	sprintf(arr,"%.2f-%c-%d",s.f,s.c,s.a);
	printf("%s\n",arr);

	struct Stu tmp = { 0 };//存放转回来的格式化数据
	sscanf(arr, "%f-%c-%d", &(tmp.f), &(tmp.c), &(tmp.a));
	printf("%.2f\n", tmp.f);
	printf("%c\n", tmp.c);
	printf("%d\n",tmp.a);

	return 0;
}

结果：

随机读写

前言：文件的随机读写不是随机读写，而是可以指定读写的位置。下面介绍三个函数

1.fseek函数

作用：根据文件指针的位置和偏移量来定位文件指针。

origin只有下面三种选择：

（1）SEEK_SET：文件的起始位置

（2）SEEK_CUR：文件当前指针（光标）的位置

（3）SEEK_END：文件的末尾位置

而偏移量offset需要计算

具体实例：

（1）在文档中存放数据

（2）代码

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//读文件
	int ch = 0;
	ch = fgetc(pf);
	printf("%c\n",ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	return 0;
}

下次再输入并且打印，就会是d;但是我们可以通过改变光标的位置，进而改变输入的内容。

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//读文件
	int ch = 0;
	ch = fgetc(pf);
	printf("%c\n",ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	fseek(pf,-3, SEEK_CUR);

	ch = fgetc(pf);
	printf("%c\n", ch);

	return 0;
}

结果：

或者：

又或者：

2.ftell函数

作用：返回偏移量

例子：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//读文件
	int ch = 0;
	ch = fgetc(pf);
	printf("%c\n",ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	int pos = ftell(pf);
	printf("%d\n",pos);

	return 0;
}

3.rewind函数

作用：让文件指针（光标位置）回到文件的起始位置

例子：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt","r");
	if (pf == NULL)
	{
		perror(fopen);
		return 1;
	}
	//读文件
	int ch = 0;
	ch = fgetc(pf);
	printf("%c\n",ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	rewind(pf);

	ch = fgetc(pf);
	printf("%c\n", ch);
	return 0;
}

结果：

四、文本文件和二进制文件

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

（1）文本文件：要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

（2）二进制文件：数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件

【例题】将10000存储到文件中，两种方式

（1）10000在内存中的存储

00000000 00000000 00100111 00010000（补码的形式）

（2）将10000以文本文件的形式存储

语法要求：会将10000当成五个字符，分别以它的ASCII码存储。

如：

（3）将10000以二进制文件的形式存储

语法要求：不需要转换，直接以数据的二进制序列进行存储。

如：

（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;
}

文档内容：

（5）通过操作观察以二进制的形式存入的值：

分析：10 27 00 00是什么？

10000的二进制序列为：00000000 00000000 00100111 00010000

转为十六进制为：0x00 0x00 0x27 0x10

当前机器以小端字节序存储，则：

总结：二进制文件就是数据直接以二进制的形式存储到文件中

五、文件读取结束与文件缓冲区

1.文件读取结束的标志

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

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

总结：根据函数的返回值判断是否结束

区别两个函数：

（1）ferror：在文件读取结束后，用来判断文件是否因为读取过程中因为遇到错误而结束（非正常结束）

（2）feof：在文件读取结束后，用来判断文件是否因为读取过程中因为遇到文件结束标志而结束（正常结束）

例子：将文档a的内容拷贝到文档b中

//data1.txt---->data2.txt
#include<stdio.h>
int main()
{
	//打开文件data1.txt
	FILE* pfread = fopen("data1.txt","r");
	if (pfread==NULL)
	{
		perror(fopen);
		return 1;
	}
	//打开文件data2.txt准备输出数据（输出到文件中）
	FILE* pfwrite = fopen("data2.txt","w");
	if (pfwrite == NULL)
	{
		perror("fopen");
		fclose(pfwrite);
		return 1;
	}
	//数据拷贝
	int ch = 0;
	while ((ch = fgetc(pfread)) != EOF)//当等于EOF，读取结束
	{
		fputc(ch,pfwrite);
	}

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

拷贝后：

可以利用这个操作，保存程序中的内容

2.文件缓冲区

缓冲区的作用：

（1）从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。

（2）如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）

图解：

代码：

#include <stdio.h>
#include <windows.h>
//VS2013 WIN10环境测试
int main()
{
	FILE* pf = fopen("test.txt", "w");
	fputs("abcdef", pf);//先将代码放在输出缓冲区
	printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
	Sleep(10000);

	printf("刷新缓冲区\n");
	fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
	//注：fflush 在高版本的VS上不能使用了

	printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
	Sleep(10000);
	fclose(pf);
	//注：fclose在关闭文件的时候，也会刷新缓冲区
	pf = NULL;
	return 0;
}

结果说明：存在缓冲区，当在休眠的10秒内，文档中还没有内容

刷新缓冲区的条件：