C语言进阶：文件操作

目录

什么是文件

文件名

文件类型

文件缓冲区

文件指针

文件的打开和关闭

文件的顺序读写

文件的随机读写

文件结束的判定

什么是文件

磁盘上的文件是文件

但是再程序设计中，我们一般谈的文件有两种：程序文件、数据文件。

程序文件

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

数据文件

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

接下来用一张图片来区分程序文件与数据文件

本章讨论的是数据文件

在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。

其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上的文件。 

文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用

文件名包含3部分：文件路径+文件名主干+文件名后缀

例如：d:codetest.txt

为了方便起见，文件标识常被称为文件名

文件类型

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

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

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

那么一个数据在内存中是怎么存储的呢？

字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储

如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2013测试）

#include
int main()
{
	int a = 10000;
	FILE *pf = fopen("test.txt", "wb");
	fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
	fclose(pf);
	pf = NULL;
	return 0;
}

我们用二进制编辑器查看以二进制形式写入文件的10000，可以看到如下现象：

文件缓冲区

ANSIC标准采用缓冲文件系统处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块文件缓冲区。

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

2.同样的如果要从磁盘向计算机读入数据，从磁盘文件中读取数据会先输入到内存的缓冲区（输入缓冲区），装满缓冲区后再从缓冲区逐个地将数据送到程序数据区。

3.缓冲区的大小是根据C编译系统决定的。

他们之间的关系我们可以用下面的一张图来表示

验证缓冲区的存在

//验证文件缓冲区的存在
//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;
}

  

文件指针

缓冲文件系统中，关键的概念是文件类型指针，简称文件指针。

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

例如，VS2008编译环境提供的stdio.h头文件中有以下的文件类型申明：

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 *pf;//文件指针变量

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

比如：

文件的打开和关闭

想通过文件指针来进行文件操作，必须得先打开文件，使用结束后得关闭文件。操作文件的步骤分为三步：1.打开文件.2.读/写文件.3.关闭文件.

在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。

ANSIC规定使用fopen函数来打开文件，fclose来关闭文件

FILE *fopen( const char *filename, const char *mode );
//fopen的第一个参数是文件名
//fopen的第二个参数是打开方式

int fclose( FILE *stream );
//fclose的参数是文件指针
//也就是说你要关闭哪个文件，就把那个文件的文件指针交给fclose就好了
//由于它只关闭了关于文件的输入输出流，不会将指针置空，所以为了避免野指针的出现一定要记得将文件指针置为空指针

打开方式如下：

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

下面用代码来实现一下打开文件：

int main()
{
	//打开文件
	FILE *pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

 下面我们还需要说明的是：打开文件有两种方式一种是通过绝对路径打开，一种是通过相对路径来打开

//打开文件

//1.绝对路径
FILE *pf = fopen("C:\Users\33207\OneDrive\桌面\data.txt","w");
//这里多加了是为了防止它被解释为一个转义序列符

//2.相对路径
FILE *pf = fopen("data.txt","w");

文件的顺序读写

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

对于输入和输出应该怎么理解呢？

我自己的理解是这样的：在学习的过程中也有输入与输出的概念，从别人那里学到东西，获得知识的这个过程就叫做输入。但是学习的过程中不能只有输入而没有输出，所以我们通过练习我们学到的东西和知识或者把我们的学到的东西去教给别人的这个过程就叫做输出。

同样的那么在计算机中只需要把自己看成是数据就好了，我要从文件那里读东西这就叫做输入，我要把数据给文件或者说写到文件里面去这就叫做输出。

 字符输出函数fputc

函数声明

int fputc( int c, FILE *stream );

//c表示要写到文件中那个的字符

//FILE的结构指针

fputc写到标准输出流（屏幕）

int main()
{
	fputc('b', stdout);//putchar  printf("%c", ch);
	fputc('i', stdout);
	fputc('t', stdout);

	return 0;
}

函数的使用

int main()
{
	FILE *pf = fopen("C:\Users\33207\OneDrive\桌面\data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	//写文件
	fputc('b', pf);
	fputc('i', pf);
	fputc('t', pf);

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


}

当程序执行起来的时候可以看到文本文件中存放了bit3个字符

那么这个时候大家可能就会有点好奇，fputc函数是怎么把字符写入到文件中的呢？

其实是这样的：pf这个文件信息区中会有一个标记文件位置的指针，当我们每写入一个字符，该指针就会向后偏移，这样子一步一步就能进这些字符写入到文件中。

fputc它是适用于所有输出流的（文件/标准输出流）

在介绍fgetc之前我们先来讲一下——流

在C语言中有一个流的概念，流是一个高度抽象的概念，你可以把它看作水流。一些外部设备比如说：文件、屏幕、网络、光盘以及软盘我们可以从中读写一些数据，但是不同的外部设备的读写方式肯定不一样。当有了流之后程序员就只需要关心如何往流里面输入数据，并不需要关心数据给谁，数据给谁这件事就让流来做就好了。

C语言的程序只要运行起来，就默认打开了3个流

  

字符输入函数fgetc

函数声明

int fgetc( FILE *stream );

函数使用

int main()
{
		FILE *pf = fopen("C:\Users\33207\OneDrive\桌面\data.txt", "r");
		if (pf == NULL)
		{
			perror("fopen");
			return -1;
		}
		//读文件
		int ch = fgetc(pf);
		printf("%cn", ch);

		ch = fgetc(pf);
		printf("%cn", ch);

	    ch = fgetc(pf);
		printf("%cn", ch);
	
		//关闭文件
		fclose(pf);
		pf = NULL;
	
		return 0;
}

打印结果：

pf信息区中会有一个标识文件位置的指针，读完一个字符之后，指针就会往后偏移。这样它就将数据依次读了进来，然后通过printf打印到屏幕上。

fgetc函数读取标准输入流（键盘）

int main()
{

	int ch = fgetc(stdin);//getchar scanf("%c")
	printf("%cn", ch);//a

	ch = fgetc(stdin);
	printf("%cn", ch);//b

	ch = fgetc(stdin);
	printf("%cn", ch);//c

	return 0;
}

文本行输出函数fputs

函数声明

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


//第一个参数：想要输出的字符串

//第二个参数：FILE的结构指针

函数的使用

int main()
{
	FILE *pf = fopen("data.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//写文件
	//写一行数据
	fputs("hello worldn", pf);
	fputs("hello bitn", pf);

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

程序运行的结果：

可以看到这两个字符串成功写到了文件中去，但是你如果想让它换行就必须自己在字符串后面加上'n'

 文本行输入函数fgets

函数声明

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

//第一个参数是数据存储的位置，也叫是说你读的数据要放到哪里去

//第二个参数表示的是你一次最多读多少个字符

//第三个参数表示FILE结构的指针

函数使用

int main()
{
	FILE *pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//读文件
	//读一行数据
	char arr[20] = { 0 };
	fgets(arr, 5, pf);
	printf("%sn", arr);

	fgets(arr, 5, pf);
	printf("%sn", arr);

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

打印的结果：

看到我们的打印结果是不是觉得很奇怪，我上面可读最大字符数明明给的是5，可是打印的结果好像只给我读了4个字符，这是为什么呢？

原因是：fgets这个函数它实际上只读n-1个字符，最后一个会放''，如果n大于要读的字符串长度，那么它把这一行的数据读完就不会再读了，并且也不会接着读下一行。 

格式化输出函数fprintf

功能：把格式化的数据输出到所有输出流（屏幕/文件）上

函数声明

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

我们可能对这个函数不太熟悉，但是我们对于printf这个函数是很熟悉的那么我们就用类比法，将他俩对比来看

我们可以看到fprintf和printf的参数大致一样，就是fprintf比printf多了一个FILE的结构指针 

那么我们下面来用一下它吧

int main()
{
	struct S s = { 100, 3.14 };
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//写文件
	fprintf(pf,"%d %lf", s.n, s.d);

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

输出结果

格式化输入函数fscanf

功能：从所有输入流读取格式化的数据

函数声明

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

 同样的我们将它与scanf对比着来看

我们可以看到fscanf和scanf的参数大致一样，就是fscanf比scanf多了一个FILE的结构指针 

那么我们下面来用一下它吧

struct S
{
	int n;
	double d;
};
int main()
{
	struct S s = { 100, 3.14 };
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//读文件
	fscanf(pf, "%d %lf", &(s.n), &(s.d));
	printf("%d %lf", s.n, s.d);

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

打印的结果

二进制输出函数fwrite

功能：以二进制的方式将程序中的数据写到文件中

函数声明

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

//buffer：指向要写入数据的指针
//size：写的一个元素的大小
//count：要写元素的最大个数
//stream：FILE的结构体指针

函数的使用

//fwrite函数
struct S
{
	int n;
	double d;
	char name[10];
};
int main()
{
	struct S s = { 100, 3.14 };
	FILE* pf = fopen("data.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}

	//写文件-二进制的方式写
	fwrite(&s,sizeof(s),1,pf);

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

打印结果

我们可以看到打印的结果中除了zhangsan以外，其他的我们是看不懂的这是为什么呢？

因为字符串本身就是以文本形式存放的，而剩下的其他数据是以二进制的形式写到文件里面去的，自然我们就看不懂了（当然懂的人除外）

二进制输入函数fread

功能：从一个流中读取count个大小为size（单位是字节）的数据到buffer里面去

函数声明

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

//buffer：数据存储的位置

//size：每个元素的大小（单位是字节）

//count：要读取的最大的元素个数

//stream：FILE结构的指针

函数的使用

//fread函数
struct S
{
	int n;
	double d;
	char name[10];
};
int main()
{
	struct S s = { 0 };
	FILE* pf = fopen("data.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return -1;
	}
	//读文件-二进制的方式读
	fread(&s, sizeof(s), 1, pf);

	//打印
	printf("%d %lf %s", s.n, s.d, s.name);
	//100 3.140000 zhangsan

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

打印结果

下面我们来对比一组函数

scanf/fscanf/sscanf

printf/fprintf/sprintf

scanf	从标准输入流（键盘）读取格式化的数据
fscanf	从所有输入流中读取格式化的数据
sscanf	从字符串中读取一个格式化的数据/把一个字符串转换成一个格式化的数据
printf	把格式化的数据输出到标准输出流（屏幕）上
fprintf	把格式化的数据输出到所有输出流（屏幕/文件）上
sprintf	把格式化的数据转换成对应的字符串

sprintf函数

函数声明

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

功能：把格式化的数据转换成对应的字符串

函数使用

//sprintf函数
struct S
{
	int n;
	double d;
	char name[10];
};
int main()
{
	char arr[100] = { 0 };
	struct S s = { 100, 3.14, "zhangsan" };
	//把一个格式化的数据转换成字符串
	sprintf(arr, "%d %lf %s", s.n, s.d, s.name);

	//打印
	printf("%sn", arr);

	return 0;
}

打印结果

sscanf函数 

函数声明

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

功能：把一个字符串转换成对应的格式化数据

函数使用

//sprintf函数与sscanf函数
struct S
{
	int n;
	double d;
	char name[10];
};
int main()
{
	char arr[100] = { 0 };
	struct S tmp = { 0 };
	struct S s = { 100, 3.14, "zhangsan" };
	//把一个格式化的数据转换成字符串
	sprintf(arr, "%d %lf %s", s.n, s.d, s.name);

	//打印
	printf("%sn", arr);
	//从arr中的字符串中提取出一个结构化的数据
	sscanf(arr, "%d %lf %s", &(tmp.n), &(tmp.d), &(tmp.name));

	printf("%d %lf %s", tmp.n, tmp.d, tmp.name);

	return 0;
}

打印结果

 

文件的随机读写

fseek函数

根据文件指针的位置和偏移量来定位文件指针

函数声明

int fseek( FILE *stream, long offset, int origin );

//stream：FILE结构的指针

//offset：偏移量

//origin：起始位置

SEEK_CUR

Current position of file pointer  文件指针当前的位置

SEEK_END

End of file  文件终点

SEEK_SET

Beginning of file  文件的起始位置

这里还需要注意的是如果文件指针指向的是a的话，那么当你要读b，c，d，e，f的时候，他们相对于a的偏移量分别是1，2，3，4，5。如果文件指针指向的是c的话，当你要读d，e，f他们相对于c的偏移量就是1，2，3。而当你要读a，b的时候他们相对于c的偏移量就是-2，-1，并且读了一个字符之后该文件指针会向后偏移。

 函数的使用

//文件的随即读写
//fseek函数
int main()
{
	//1.打开文件
	FILE *pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//2.读文件
	//随机读写
	//如果第一次就要读取'c'
	fseek(pf, 2, SEEK_SET);
	int ch = fgetc(pf);
	printf("%cn",ch);

	//接下来我想读取'b'
	fseek(pf, -2, SEEK_CUR);
	ch = fgetc(pf);
	printf("%cn", ch);

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

打印结果

 我们可以看到每读取一个字符，文件指针就会往后偏移。从打印的结果来看fseek是具有移动文件指针的能力的，配合着fgetc函数的使用，可以说是指哪打哪，想读谁就读谁。

看了fseek函数之后可能就会有人问了，那我要是不知道偏移量怎么办呢？接下来要介绍的这个函数就是来求偏移量的。

ftell函数

返回文件指针相对于起始位置的偏移量

函数声明

long ftell( FILE *stream );

函数的使用

//文件的随即读写
int main()
{
	//1.打开文件
	FILE *pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//2.读文件
	//随机读写
	//如果第一次就要读取'c'
	fseek(pf, 2, SEEK_SET);
	int ch = fgetc(pf);
	printf("%cn",ch);

	//接下来我想读取'b'
	fseek(pf, -2, SEEK_CUR);
	ch = fgetc(pf);
	printf("%cn", ch);

	//计算文件指针相对于起始位置的偏移量
	int ret = ftell(pf);
	printf("%dn", ret);

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

打印结果

 rewind函数

让文件指针的位置回到文件的起始位置

函数声明

void rewind( FILE *stream );

函数的使用

//文件的随即读写
int main()
{
	//1.打开文件
	FILE *pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return -1;
	}
	//2.读文件
	//随机读写
	//如果第一次就要读取'c'
	fseek(pf, 2, SEEK_SET);
	int ch = fgetc(pf);
	printf("%cn",ch);//c

	//接下来我想读取'b'
	fseek(pf, -2, SEEK_CUR);
	ch = fgetc(pf);
	printf("%cn", ch);//b

	//计算文件指针相对于起始位置的偏移量
	int ret = ftell(pf);
	printf("%dn", ret);

	//我们想让文件指针回到文件的起始位置
	rewind(pf);
	ch = fgetc(pf);
	printf("%cn", ch);//a

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

打印结果

文件结束的判定

被错误使用的feof

函数声明

int feof( FILE *stream );

牢记：在文件读取的过程中，不能用feof函数的返回值直接用来判断文件的是否结束。

           而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

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

例如：

fgetc判断是否为EOF

fgets判断返回值是否为NULL

2.二进制文件的读取结束判断，判断返回值是否小于实际要读的个数

例如：

fread判断返回值是否小于实际要读的个数

函数的使用

int main()
{
	int c;//注意：int，非char，要求处理EOF
	FILE *pf = fopen("test.txt", "r");
	if (pf==NULL)
	{
		perror("FILE opening failed");
		return EXIT_FAILURE;
	}
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((c = fgetc(pf) != EOF)) //标准C I/O读取文件循环
	{
		putchar(c);
	}
	//判断是什么原因结束的
	if (ferror(pf))
		puts("I/O error when reading");
	else if (feof(pf))
		puts("End of file reached successfully");
	fclose(pf);

}

总结：

ferror的用途：是文件读取结束了，判断是不是遇到错误后读取结束的。

feof的用途：是文件读取结束了，判断是不是遇到文件末尾而结束的。