【进阶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 );

函数解析：

文件的打开方式：

如：

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

（4）fcolse：

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

函数解析： 

（5）打开与关闭

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

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

运行结果：

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

当前路径的文件：

添加该（文本）文档后：

结果：

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

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

相对路径： 

运行结果：

修改代码：

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

相对路径解析：

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

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

绝对路径：

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

第二步：打开文件

#include
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;
}

运行结果：

程序与文件的关系：

三、文件的读写

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

顺序读写

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

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

大致分类：

（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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 
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
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 
#include 
//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秒内，文档中还没有内容

刷新缓冲区的条件：

（1）缓冲区已满

（2）主动调用函数刷新

（3）关闭文件（fclose）

缓冲区的作用：提高代码效率