【C语言进阶（13）】文件操作

为什么要使用文件

• 程序运行起来时，程序中的数据都是放在内存中的，如果要保存这些数据不至于丢失，此时就需要使用文件来保存信息。
• 文件时放在硬盘上的数据，硬件正常的情况下放在硬盘上的文件数据是不会丢失的。

Ⅰ 什么是文件

1. 文件分类

• 在程序设计中，一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
• 文件其实就是一种存放数据的介质（媒介）。

1. 程序文件

• 写程序涉及到的文件就是程序文件。
• 包括源程序文件(后缀为.c)、目标文件(windows环境后缀为.obj)、可执行程序(windows环境 后缀为.exe)。

2. 数据文件

• 文件的内容不一定是程序，而是程序运行时读写的数据，例如程序运行需要从中读取数据的文件，或者输出内容的文件。
• 程序文件或者其他应用程序可以操作的文件，称为数据文件。
• 本文讨论的为数据文件

2. 文件名

• 一个文件要有一个唯一的文件标识，以便用户识别和引用。
• 文件名包含 3 部分：文件路径 + 文件名主干 + 文件后缀（文件名可以没有后缀）。

Ⅱ 文本文件和二进制文件

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

1. 文本文件

• 数据以ASCLL的形式存到文件里的形成叫做文本文件，也叫ASCLL文件。
• 肉眼能看的懂的是给人看的，用记事本打开是一些字符的，文本文件放的都是文本。

2. 二进制文件

• 一个数据在内存中是怎么存的放到文件里就是怎么存，以二进制的形式存到文件中。
• 肉眼看不懂，用记事本打开是一堆乱码的文件，是给机器看的。

举个例子

将 10000 存到文件中的两种方式

1. 文本文件：以 ASCII 码的形式存储。将10000分成 ‘1’,‘0’,‘0’,‘0’,‘0’, 这五个字符，存储每个字符对应的 ASCII 码值。占 5 个字节的空间。

2. 二进制文件：直接将 10000 转成二进制存储到文件当中。占 4 个字节的空间。

• 显然，将文件以二进制的形式存储不仅从安全性来说，亦或者从节省空间的角度上来看都更加适合一点。

Ⅲ 文件缓冲区

• 当一个程序要 读 / 写 文件的时候，系统会自动为这次读/写文件创建一块内存区域。
• 这块区域被称为文件缓冲区，文件缓冲区又被分为输入缓冲区和输出缓冲区。
• 从内存向磁盘输出数据会先送到内存中的输出缓冲区，装满输出缓冲区之后才一次送到磁盘上。
• 如果从磁盘上向计算机读入数据，则从磁盘文件中读取数据输入到内存中的输入缓冲区，装满输入缓冲区之后，再从缓冲区逐个的将数据送到程序数据区(程序变量等)。

举个例子

while(1)
{
	sleep (1);
	printf("hello world");
}
1
2
3
4
5

• hello world不是一股脑的全部打印出来，而是先放在输出缓冲区，等输出缓冲区满了才一次性打印到屏幕上。

Ⅳ 文件的打开和关闭

1. 文件指针

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

文件类型声明

typedef struct _iobuf 
{
	char* _ptr;
	int _cnt;
	char* _base;
	int _flag;
	int _file;
	int _charbuf;
	int _bufsiz;
	char* _tmpfname;
}FILE;
1
2
3
4
5
6
7
8
9
10
11

• 每当打开一个文件的时候，系统会根据文件的情况自动创建一个 FILE 结构的变量，并填充其中的信息。
• 一般都是通过一个 FILE 的指针来维护这个 FILE 结构的变量。
• 通过文件指针变量能够找到与它关联的文件。

定义文件指针

FILE* pf = NULL;//pf 就是一个文件指针，暂时还没有指向任何文件
1

2. 文件的打开和关闭

• 文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
• 在编写程序的时候，在打开文件的同时，会返回一个 FILE* 的指针变量指向该文件。
• ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件。
• 打开文件如果失败会返回 NULL

fopen 打开文件

FILE * fopen ( const char * filename, const char * mode );
1

• 以 mode 的形式打开 filename 文件并返回一个指向该文件的文件指针。
• 如果打开失败会返回 NULL。

fclose 关闭文件

int fclose ( FILE * stream );
1

• 关闭文件指针指向的文件。

3. 文件打开方式

举个例子

• 以 “w” 的方式打开 data.txt 文件进行写操作，如果该文件不存在，则自动创建一个 data.txt 文件。

int main()
{
	FILE* pf = fopen("data.txt", "w");	//以只写形式打开 data.txt 文件并返回指向该文件的指针

	if (NULL != pf)						//判断文件指针是否为空（文件打开失败）
	{
		//写文件操作...

		fclose(pf);							//关闭文件指针 pf 指向的文件
		pf = NULL;							//不能让该指针继续指向文件信息区
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Ⅴ 文件的顺序读写

• 按照一定的顺序对文件进行 读 / 写 操作。
• 做不到不按顺序的读写。比如 abcdef，只能从 a 开始按顺序读写，做不到一上来就对 f 进行读写。

1. fputc 写入一个字符

• 写入单个字符到文件中。

函数原型

int fputc ( int character, FILE * stream );
1

函数用例

fputc('a', pf);//将字符 a 写入到 pf 指向的文件中
1

2. fgetc 读取一个字符

• 从文件中读取一个字符到程序数据区。

函数原型

int fgetc ( FILE * stream );
1

函数用例

int ch = fgetc(pf);	//从 pf 指向的文件中读取一个字符放到 ch 中
if (ch != EOF)		//读取成功，EOF 本质是 -1 所以 ch 得是整型
{
	printf("%c\n", ch);
}
1
2
3
4
5

3. fputs 覆盖并写入一行数据

• 写入一行字符到文件中。

函数原型

char* fputs(char* string, FILE * stream);
1

函数用例

fputs("hello world!\n", pf);//将字符串覆盖写入到 pf 指向的文件中
1

4. fgets 读取指定长度的数据

函数原型

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

• 从文件指针指向的文件里，读取 num-1 个字符，放到字符串数组 str 中去。

函数用例

char str[10] = { 0 };
fgets(str, 5, pf);//从 pf 指向的 data.txt 文件中读取 5-1 个字符放到 str 中
printf("%s\n", str);
1
2
3

5. fprintf 格式化输出

• 将数据按照指定格式输出到文件中。
• printf 是将数据输出到屏幕上，fprintf 则是输出到文件里，两者的区别仅此而已。

函数原型

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

函数用例

• 将结构体信息输出文件中。

struct S
{
	float f;
	char c;
	int n;
};

int main()
{
    struct S s = { 3.14f,'w',100 };
	FILE* pf = fopen("data.txt", "w");
 
    if (NULL != pf)
    {
    	fprintf(pf, "%f %c %d", s.f, s.c, s.n);//将结构内的数据按照指定的格式输出到 pf 指向的文件中

    	fclose(pf);
    	pf = NULL;
    }

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6. fscanf 格式化输入

• 将文件中的数据按照指定的格式读取到程序中。

函数原型

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

• scanf 从键盘获取数据，fscanf 则是从文件中获取数据

函数实例

struct S
{
    float f;
    char c;
    int n;
};

int main()
{
    struct S s = { 0 };
    FILE* pf = fopen("data.txt", "r");

    if (NULL != pf)
    {
    	fscanf(pf, "%f %c %d", &(s.f), &(s.c), &(s.n));//将 pf 指向文件中的内容以指定格式读取到结构体中
    	printf("%f %c %d\n", s.f, s.c, s.n);

    	fclose(pf);
    	pf = NULL;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7. fwrite 二进制输出文件

• 将数据以二进制的形式写入到文件中。

函数原型

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

执行顺序

函数用例

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	FILE* pf = fopen("data.txt", "wb");//二进制输出

	if (pf != NULL)							//二进制的写文件
	{
		fwrite(arr, sizeof(arr[0]), sz, pf);//将 arr 内的 40 个字节的内容写入文件

		fclose(pf);
		pf = NULL;
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8. fread 读取二进制文件信息

• 将文件内容以二进制的形式读取出来。

函数原型

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

执行顺序

函数用例

int main()
{

	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	FILE* pf = fopen("data.txt", "rb");

	if (pf != NULL)
	{
		fread(arr, sizeof(arr[0]), sz, pf);//将二进制文件中的内容读取出来

		for (int i = 0; i < sz; i++)
		{
			printf("%d ", arr[i]);
		}

		fclose(pf);
		pf = NULL;
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

9. sprintf 格式化数据转换成字符串

• 将格式化的数据输出到字符串中。

函数原型

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

函数用例

struct S
{
	float f;
	char c;
	int n;
};

int main()
{
	struct S s = { 3.14f,'w',100 };
	char str[100] = { 0 };

	sprintf(str, "%f %c %d", s.f, s.c, s.n);//将指定格式的数据转换成字符串后存到 str 中
	printf("%s\n", str);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

10. sscanf 字符串转换成格式化数据

• 从字符串中将数据以格式化的形式输入。

函数原型

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

函数用例

struct S
{
	float f;
	char c;
	int n;
};

int main()
{
	struct S s = { 0 };
	char str[100] = "3.140000 w 100";

	sscanf(str, "%f %c %d", &(s.f), &(s.c), &(s.n));//str 内的数据转换成指定格式然后输入到结构体中
	
	printf("%f %c %d\n", s.f, s.c, s.n);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Ⅵ 文件的随机读写

• 文件的顺序读写只能按照顺序进行读写，abcdef 只能从 a 开始读写，做不到一上来就对 f 进行读写，所以这时候就有了随机读写函数。

1. fseek

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

函数原型

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

• offset：偏移量，根据文件指针的位置偏移 offset 个字节找到该字符
• origin：文件指针的起始位置

起始位置

1. SEEK_CUR：文件指针的当前位置。
2. SEEK_END：文件的末尾位置（末尾：最后一个字符的后面）。
3. SEEK_SET：文件的起始位置。

函数用例

int main()
{
	int ch = 0;
	FILE* pf = fopen("data.txt", "r");

	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//要读取从头开始向后偏移 2 个单位的字符
	fseek(pf, 2, SEEK_SET);//从头开始
	ch = fgetc(pf);
	printf("从头开始读取：%c\n", ch);

	//拿到当前文件指针所处位置向后偏移 2 个单位的字符
	fseek(pf, 2, SEEK_CUR);//从当前位置开始
	ch = fgetc(pf);
	printf("从当前位置开始读取：%c\n", ch);

	//要读取从尾开始向前偏移 2 个单位的字符
	fseek(pf, -2, SEEK_END);//从尾开始
	ch = fgetc(pf);
	printf("从尾开始读取：%c\n", ch);

	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2. ftell

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

函数原型

long int ftell ( FILE * stream );
1

函数用例

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

	if (NULL != pf)
	{
		int ch = 0;
		ch = fgetc(pf);//在读取一个字符之后，文件指针自动向后偏移一个单位

		printf("文件指针相对于文件起始位置的偏移量是 %d\n", ftell(pf));

		fclose(pf);
		pf = NULL;
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. rewind

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

函数原型

void rewind ( FILE * stream );
1

函数用例

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

    int ch1 = fgetc(pf);//获取字符a，然后让文件指针往后偏移 1 位指向 b,
    printf("%c\n", ch1);

    rewind(pf);         //让文件指针回到文件的起始位置，还是指向 a

    int ch2 = fgetc(pf);//还是获取字符a
    printf("%c\n", ch2);

    fclose(pf);
    pf = NULL;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Ⅶ 文件读取结束的判定

1. 错误使用的 feof

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

feof 的作用

• 当文件读取结束的时候，判断读取结束的原因是否是遇到文件尾结束

判断文件是否读取结束

1. 文本文件：判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
2. 二进制文件：判断返回值是否小于实际要读的个数。

2. 正确使用的 feof

判断文件文件读取结束的两个函数

• ferror：在文件读取结束后，用来判断文件是否因为读取过程中遇到错误而结束。
• feof：在文件读取结束后，用来判断你文件是否引文读取过程中遇到文件结束标志而结束。

文本文件的例子

int main()
{
	int ch = 0;		//EOF 本质是 -1，ch 得是整型才能和 EOF 比较
	FILE* pf = fopen("data.txt", "r");

	if (NULL == pf) 
	{
		perror("fopen");
		return 1;
	}
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((ch = fgetc(pf)) != EOF) 
	{
		putchar(ch);
	}

	//判断是什么原因结束的

	if (ferror(pf))		//
	{ 
		puts("I/O error when reading");
	}
	else if (feof(pf))	//文件正常读取结束
	{
		puts("End of file reached successfully");
	}

	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

二进制文件的例子

#define SIZE 5

int main()
{
	FILE* pf = fopen("data.txt", "rb");
	int arr[SIZE] = { 0 };

	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	size_t num = fread(arr, sizeof(arr[0]), SIZE, pf);
	//fread 的返回值是每次读取到的字符个数

	if (SIZE == num)//返回值如果是读取到的字符个数，则读取成功
	{
		printf("Array read successfully\n");
	}
	else			//汇报读取失败的原因
	{
		
		if (ferror(pf))
		{
			printf("读取中出现错误\n");
		}
		else if (feof(pf))
		{
			printf("读取到文件尾\n");
		}
	}

	fclose(pf);
	pf = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38