文件操作详解

Seaside.

已于 2024-04-19 11:01:43 修改

阅读量841

点赞数 16

分类专栏： C语言文章标签： c语言

于 2024-02-23 19:56:52 首次发布

本文链接：https://blog.csdn.net/g1569357228/article/details/136135541

版权

C语言专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、为什么使用文件？

如果没有文件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运行程序，是看不到上次程序的数据的，如果要将数据进行持久化的保存，我们可以使用文件。

二、什么是文件？

磁盘上的文件是文件。

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

1.程序文件

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

2.数据文件

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

       本章讨论的是数据文件。
       在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
      其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。

3.文件名

⼀个文件要有⼀个唯⼀的文件标识，以便用户识别和引用。文件名包含3部分：文件路径+文件名主干+文件后缀。例如： c:\code\test.txt。为了方便起见，文件标识常被称为文件名。

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

       根据数据的组织形式，数据文件被称为文本文件或者⼆进制文件。数据在内存中以⼆进制的形式存储，如果不加转换的输出到外存，就是⼆进制文件。如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
       ⼀个数据在内存中是怎么存储的呢？
       字符⼀律以ASCII形式存储，数值型数据既可以⽤ASCII形式存储，也可以使用⼆进制形式存储。如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符⼀个字节），而⼆进制形式输出，则在磁盘上只占4个字节（VS2019测试）。

四、文件的打开和关闭

1.流

我们程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，不同的外部设备的输入输出操作各不相同，为了方便程序员对各种设备进行方便的操作，我们抽象出了流的概念，我们可以把流想象成流淌着字符的河。C程序针对文件、画面、键盘等的数据输入输出操作都是通过流操作的。⼀般情况下，我们要想向流里写数据，或者从流中读取数据，都是要打开流，然后操作。

2.标准流

那为什么我们从键盘输入数据（读），向屏幕上输出数据（写），并没有打开流呢？

那是因为C语⾔程序在启动的时候，默认打开了3个流：
stdin 标准输入流，在大多数的环境中从键盘输入，scanf函数就是从标准输入流中读取数据。
stdout 标准输出流，大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。
stderr 标准错误流，大多数环境中输出到显示器界面。

这是默认打开了这三个流，我们使⽤scanf、printf等函数就可以直接进行输入输出操作的。stdin、stdout、stderr三个流的类型是： FILE* ，通常称为文件指针。C语⾔中，就是通过 FILE* 的⽂件指针来维护流的各种操作的。

3.文件指针

缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。每个被使⽤的文件都在内存中开辟了⼀个相应的文件信息区，⽤来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在⼀个结构体变量中的。该结构体类型是由系统声明的，取名FILE.

下⾯我们可以创建⼀个FILE*的指针变量:

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

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

4.fopen 和 fclose

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

//打开⽂件
FILE * fopen ( const char * filename, const char * mode );
//第一个参数为文件名，第二个参数为打开模式。
//关闭⽂件
int fclose ( FILE * stream );

mode表示文件的打开模式，以下是文件的打开模式：

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

代码示例：

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

程序运行结束之后，我们会发现代码目录下多了test.txt这个文件。

5.文件的创建

当双引号内只有文件名时，就在我们写的代码的文件里面创建文件，我们也可以改变创建的路径，比如创建在桌面上，那就可以这样写：

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf = fopen("D:\\Onedrive\\桌面\\test.txt", "w");
    //有两个斜杠的原因是‘\’是个转义字符，前面再加个‘\’将后面的转义字符给转义成普通的斜杠。
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

再来打开桌面，可以发现文件就被创建在桌面上了。

以上所写的路径成为“绝对路径”，那么肯定还有相对路径。当我们想要将文件创建在默认路径的上一个路径，可以这样写：

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf = fopen("./../test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

其中引号内的"."和“..”表示当前路径和上一级路径，两个连在一起意思就是当前路径的上一个路径。

可以看到，我们代码的上一级路径成功地创建出了test.txt文件。

6.一些其他特征

（1）当以只写模式（w）、二进制形式写（wb）、读写模式（w+）、二进制模式读写（wb+）的形式打开时，文件里面的内容会被清空。

五、文件的顺序读写

1.顺序读写函数


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

2.fputc

int fputc ( int character, FILE * stream );
//参数1：可以是一个字符，也可以是一个整形，整形代表ASCII码值。
//参数2：流

假如我们要写一个字符到文件里面：

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf = fopen("test.txt", "wb+");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fputc('a', pf);
	fputc('b', pf);
	fputc('c', pf);
	fputc('d', pf);
	fputc('e', pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

程序运行完成：

假如想要将刚才的字符打印在屏幕上，只需将pf改成stdout就可以。

3.fgetc

int fgetc ( FILE * stream );

读取成功则返回该字符的ASCII码值，读取失败则返回EOF。

连续读取文件中的字符

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf = fopen("test.txt", "r+");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	char ch = fgetc(pf);
	printf("%c ", ch);
	ch = fgetc(pf);
	printf("%c ", ch);
	ch = fgetc(pf);
	printf("%c ", ch);
	ch = fgetc(pf);
	printf("%c ", ch);
	ch = fgetc(pf);
	printf("%c ", ch);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

当打开文件的时候，光标是指向开头的，每读取一次，光标向后移动一位。

结果如下图所示：

下面来做一道题：

写一个代码，完成将data1.txt文件的内容，拷贝一份，生成data2.txt文件。

代码实现：

先将data1.txt里面放入一些内容：

代码实现：

#include<stdio.h>

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "r+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	FILE* pf2 = fopen("data2.txt", "w+");
	if (pf2 == NULL)
	{
		fclose(pf1);
		pf1 = NULL;//为了使代码更严谨，这里如果打开文件2失败了，先关掉文件1，再将文件指针置为空，最后再返回。
		perror("fopen data2");
		return 1;
	}
	char ch;
	//数据的读写和拷贝
	while ((ch = fgetc(pf1))!=EOF)//读取一个字符就往另一个文件里面写一个字符
	{
		fputc(ch, pf2);
	}
	//关闭文件
	fclose(pf1);
	fclose(pf2);
	pf1 = NULL;
	pf2 = NULL;
	return 0;
}

结果如下图所示：

4.fputs

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

参数1代表一串字符串，参数二是流。

假如要写一串字符串：

可以看到，右图中字符串连到了一块，那么想要分行，就在每个字符串后面加上换行符‘\n’。

5.fgets

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

参数1表示将读取到的数据放到str所指向的空间里面，参数2表示最多读取num-1个字符。

我们在文件里面先添加一些数据：

运行这个程序：

当程序执行完fgets这条语句时，右边监视窗口可以观察到arr里面前六个已经被改变了。

fgets函数会将num-1个数据存储到指定的位置，并在后面加上一个'\0'字符。

6.fprintf

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

它的参数和printf函数参数类似，它的第一个参数为一个流。

它用来写一些格式化的数据到流里面。

假如要写一个学生的信息，有姓名、年龄等，我们可以先用一个结构体来定义，在将信息写到文件里面。

struct Test
{
	char name[20];
	int age;
}test;

int main()
{
	struct Test test = { "zhangsan",19};
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "r+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	fprintf(pf1, "%s %d", test.name, test.age);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

这样就可以将一个人的信息写到文件里面。

7.fscanf

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

它的参数也比scanf函数多了一个流。

如果我们想要将文件里面的内容放到一个结构体里面去，可以这样写：

struct Test
{
	char name[20];
	int age;
}test;

int main()
{
	struct Test test = { 0 };
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "r+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	fscanf(pf1, "%s %d", test.name, &test.age);
	printf("%s %d\n", test.name, test.age);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

8.fwrite

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

参数一是一个地址，该地址指向一个等待被写进流的数据的首个数据，第二个参数是单个数据的大小，如char类型是1，int是4。第三个参数是要写多少个数据，第四个参数是流。

假如我么想要以二进制方式将学生的信息写到文件里面：

struct Test
{
	char name[20];
	int age;
}test;

int main()
{
	struct Test test = { "zhangsan",18};
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "rb+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	fwrite(&test, sizeof(test), 1, pf1);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

运行程序，得到的结果如图所示：

9.fread

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

它的作用是把流stream里面的count个大小为size的数据读出来放到ptr指向的空间里面。

现在我们要将写在文件里面的数据读出来：

struct Test
{
	char name[20];
	int age;
}test;

int main()
{
	struct Test test = { "zhangsan",18};
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "rb+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	fread(&test, sizeof(test), 1, pf1);
	printf("%s %d", test.name, test.age);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

结果如下图所示：

10.sprintf

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

它的作用为将格式化数据写入str指向的字符串。

代码示例：

struct Test
{
	char name[20];
	int age;
}test;

int main()
{
	struct Test test = { "zhangsan",18 };
	char arr[100] = { 0 };
	sprintf(arr, "%s %d", test.name, test.age);//将生成的字符串放入arr数组中
	return 0;
}

调试一下代码：

可以看到，字符串已经存入arr数组，并且他们的类型是char类型。

11.sscanf

int sscanf ( const char * s, const char * format, ...);

作用：从一个字符串 s 中读取格式化的数据放到指定的位置。

代码示例：

struct Test
{
	char name[20];
	int age;
}test;

int main()
{
	struct Test test = { "zhangsan",18 };
	struct Test tmp = { 0 };
	char arr[100] = { 0 };
	sprintf(arr, "%s %d", test.name, test.age);//先将test里面的格式化数据转换成字符串放到arr里面
	sscanf(arr, "%s %d", tmp.name, &tmp.age);//然后再将arr里面的字符串转换为带格式的数据并存入tmp数组里面
	printf("%s %d", tmp.name, tmp.age);
	return 0;
}

调试一下，结果如下图所示：

tmp里面的数据都已经是带格式的了。

六、文件的随机读写

所谓随机读写，也可以看成随心读写，也就是说，我们可以任意地控制文件光标的位置来实现不同位置的读写。

1.fseek

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

第一个参数为流，第二个参数为偏移量第三个参数为起始位置。它的作用为在stream中从origin位置开始计算偏移量offset，然后将光标移动到此位置。假如文件里面存有字符“abcd”，origin为SEEK_SET，offset为2，那么文件光标就来到了b和c之间。向右偏移，偏移量>0,向后偏移，偏移量<0。

对于第三个参数，有三个选择：

常数	光标位置
SEEK_SET	文件的起始位置
SEEK_CUR	文件的目前位置
SEEK_END	文件的末尾

代码示例：

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "rb+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	char ch;
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	fseek(pf1, 2, SEEK_SET);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

结果如下图所示：

2.ftell

long int ftell ( FILE * stream );

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

代码示例：

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "rb+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	char ch;
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	int ret = ftell(pf1);
	printf("%d\n", ret);
	fseek(pf1, 2, SEEK_SET);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

运行结果如下图所示：

可以看出，此时文件光标相对于起始位置的偏移量为4。

我们也可以通过fseek和ftell来计算文件内一共有多少个字节。

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "rb+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	fseek(pf1, 0, SEEK_END);//让光标指向末尾位置
	int ret = ftell(pf1);//然后再计算相对于起始位置的偏移量
	printf("%d\n", ret);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

结果如下图所示：

3.frewind

void rewind ( FILE * stream );

作用：让文件光标回到文件的起始位置

int main()
{
	//打开文件，为了写
	//如果打开失败，则返回空指针
	FILE* pf1 = fopen("data1.txt", "rb+");
	if (pf1 == NULL)
	{
		perror("fopen data1");
		return 1;
	}
	char ch;
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	rewind(pf1);//让文件光标回到起始位置。
	ch = fgetc(pf1);
	printf("%c", ch);
	ch = fgetc(pf1);
	printf("%c", ch);
	fclose(pf1);
	pf1 = NULL;
	return 0;
}

程序运行结果如下图所示：

七、文件读取结束的判定

1.feof和ferror

int feof ( FILE * stream );

int ferror ( FILE * stream );

feof作用：当文件读取结束的时候，判断读取结束的原因是否为遇到文件尾结束。

ferror作用：在文件读取结束后，判断是否是因为遇到错误而结束。

要判断文本文件是否读取结束，判断返回值是否为EOF或者NULL。当使用fgetc读取文件时，遇到文件末尾或者遇到错误会返回EOF，使用fgets则返回NULL。

示例：

int main()
{
	int c;
	FILE* pf = fopen("data1.txt", "r+");
	if (!pf)
	{
		perror("File opening failed");
		return 1;
	}
	//fgetc当读取失败的时候或者遇到文件的时候，都会返回EOF
	while ((c = fgetc(pf))!=EOF)//标准C I/O读取文件循环
	{
		putchar(c);
	}
	putchar('\n');
	//判断是什么原因结束的
	if (ferror(pf))
		puts("I/O error when reading");
	else if (feof(pf))
		puts("End of file reached successfully");
	fclose(pf);
	return 0;
}

要判断二进制文件是否读取结束，就判断fread的返回值是否小于实际要读的个数。fread的返回值是返回实际读取元素的个数。

示例：

enum { SIZE = 5 };

int main()
{
	double a[SIZE] = { 1.,2.,3.,4.,5. };//1.0、2.0、3.0、4.0、5.0
	FILE* fp = fopen("test.bin", "wb"); // 必须⽤⼆进制模式
	fwrite(a, sizeof(*a), SIZE, fp); // 将数组里面的元素写进test.bin里面
	fclose(fp);
	double b[SIZE];
	fp = fopen("test.bin", "rb");
	size_t ret_code = fread(b, sizeof * b, SIZE, fp); // 读取test.bin里面的数据
	if (ret_code == SIZE)//如果ret_code接收到的返回值与size相同，那么说明已经读取到尾部。
	{
		puts("Array read successfully, contents: ");
		for (int n = 0; n < SIZE; ++n) printf("%f ", b[n]);
		putchar('\n');
	}
	else//否则判断一下造成读取失败的原因是什么
	{ 
		if (feof(fp))
			printf("Error reading test.bin: unexpected end of file\n");//不是预期的文件末尾
		else if (ferror(fp))
		{
			perror("Error reading test.bin");
		}
	}
	fclose(fp);
	return 0;
}

八、文件缓冲区

ANSIC标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每⼀个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。

代码示例：

#include<stdio.h>
#include<Windows.h>

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

这里可以得出一个结论：

因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件问题。