【C语言】文件操作（万字详解，教你掌握文件操作）

1.为什么使用文件

当我们完成一个小程序（如：通讯录），当通讯录运行起来时，可以给通讯录中增加、删除数据，此时数据是存放在内存中的，当程序推出后，通讯录中的数据自然就不存在了，等到下一次再次运行后，数据又得重新录入，如果使用这样的通讯录就很难受。

我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

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

• 文件可以帮我们把数据持久化存储起来

2.什么是文件

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

2.1程序文件

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

2.2数据文件

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

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

2.3文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包括3部分：

文件路径+文件名主干+文件后缀
例如：C:\code\test.txt
为了方便起见，文件标识被称为文件名。

3.文件的打开和关闭

3.1文件指针

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

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

如下为VS2013编译环境提供的stdio.h头文件中有以下的文件类型声明：

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

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。

每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。

一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。

FILE* pf;//文件指针变量
1

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

3.2文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束后应该关闭文件。

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

ANSIC（标准C，ANSI：美国国家标准总局）规定使用fopen函数来打开文件，fclose来关闭文件。

fopen打开文件

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

• filename：文件名
• mode：文件的打开方式

fclose关闭文件

int fclose(FILE* stream);
1

• 关闭文件不会使指向文件的指针置空。
  文件的打开和关闭：

int main()
{
	//fopen中的路径为相对路径
	FILE* ptf = fopen("test.txt", "w");

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

	fclose(ptf);
	ptf = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.文件的读写顺序

• 对文件进行读操作后，可以在源文件所在的文件夹中找到自己所创建的文件。

字符

fputc

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

• 字符写入文件夹，然后自动前进1（到下一位，方便下一次字符写入）
• 按照顺序去写

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
    if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//输入文本
	for (int i = 0; i < 26; i++)
	{
		fputc('a' + i, 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

fgetc

int fgetc(FILE* stream);
1

• 当fgetc遇到文件末尾时返回EOF

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//读文本
	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c ", 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

文件行

fputs

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

• 不会将str字符串中的结束符’\0’包含其中
• 按行输入不会自动换行，如果str中不包含换行符’\n’，那下一次字符串输入的起始位置紧跟上一次起始位置。

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//写文件一行一行写
	fputs("hello\n", pf);
	fputs("world\n", pf);
	fputs("YX\n", pf);//最后输出的字符串包含换行符，文件夹中就会有4行

	//关闭文件
	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

fgets

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

num：真实读取的数量为num-1个，最后一个字符需要存放‘\0’

• 如果num大于文件中一行的字符个数，只读取完它的一行就结束。

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//读一行
	char arr[] = "##########";
	fgets(arr, 10, 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

• 使用两个fgets读取第二行

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//读一行
	char arr[] = "##########";
	fgets(arr, 10, pf);
	printf("%s", arr);
	fgets(arr, 10, pf);
	printf("%s", arr);

	//关闭文件
	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

格式化

fprintf

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

• 可以使用该函数向文件传输数据（如：结构体）
• format为数据说明符（如：%d、%s等）
• …：为传入的数据变量

struct S
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct S s = { "zhangsan",21,96.1f };
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fprintf(pf, "%s %d %.3f", s.name, s.age, s.score);

	//关闭文件
	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

fscanf

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

示例：

struct S
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct S s = {0};
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//读文件
	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));
	printf("%s %d %f", s.name, s.age, s.score);

	//关闭文件
	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

二进制

fwrite

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

• ptr：需要写的数据的地址
• size：传输的一个数据的大小
• count：传输数据的个数
• stream：传输的文件指针

struct S
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct S s = { "zhangsan",21,96.1f };
	//打开文件
	FILE* pf = fopen("test.txt", "wb");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//二进制写文件
	fwrite(&s, sizeof(s), 1, 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
23
24
25
26

fread

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

• 函数返回的值为传入指针ptr的size大小的数据的个数。小于等于count。小于count时说明文件中的数据已被全部读出。

struct S
{
	char name[20];
	int age;
	float score;
};

int main()
{
	struct S s = { 0 };
	//打开文件
	FILE* pf = fopen("test.txt", "rb");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//二进制读文件
	fread(&s, sizeof(s), 1, pf);
	printf("%s %d %f\n", s.name, s.age, s.score);

	//关闭文件
	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

5.输入输出

• scanf和printf都是直接使用，不需要打开文件，而对文件操作却需要打开

对任何一个C程序，只要运行起来
就默认打开3个流 ：

1. stdin - 标准输入流 - 键盘
2. stdout - 标准输出流 - 屏幕
3. stderr - 标准错误流 - 屏幕
   3个流的类型都是 FILE*

int main()
{
	int ch = fgetc(stdin);//由原本从文件中读取，改为从键盘中读取
	fputc(ch, stdout);//由原本输出到文件，改为输出到屏幕

	return 0;
}
1
2
3
4
5
6
7

6.对比一组函数

• scanf：按照一定的格式从键盘输入数据
• printf：按照一定的格式把数据打印（输出）到屏幕上。

适用于标准输入/输出流的格式化的输入/输出语句

• fscanf：按照一定格式从输入流（文件/stdiot）输入数据
• fprintf：按照一定格式从输出流（文件/stdin）输出数据

适用于所有的输入/输出流的格式化输入/输出语句

sscanf

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

• 从字符串中按照一定的格式读取出格式化的数据

sprintf

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

• 把格式化的数据按照一定的格式转换成字符串。

struct S
{
	char name[10];
	int age;
	float score;
};

int main()
{
	char buf[100] = { 0 };
	struct S s = { "zhangsan",20,95.1f };
	struct S tmp = { 0 };
	//将数据输出到数组
	sprintf(buf, "%s %d %f", s.name, s.age, s.score);
	printf("%s %d %f\n", s.name, s.age, s.score);

	//将数据从数组向tmp变量输入
	sscanf(buf, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
	printf("%s %d %f\n", tmp.name, tmp.age, tmp.score);
    
    //关闭文件
	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

7.文件的随机读写

fseek

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

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

• origin：三个位置

//SEEK_SET
//文件的随机读写
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}

	//读文件
	fseek(pf, 4, SEEK_SET);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	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

//SEEK_END
//文件的随机读写
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}

	//读文件
	fseek(pf, -2, SEEK_END);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	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

//文件的随机读写
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}

	//读文件
	fseek(pf, -2, SEEK_CUR);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	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

• 使用SEEK_CUR不可以使用负数，使用负数输出的结果是从第一个元素开始

ftell

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

long int ftell(FILE* stream);
1

//文件的随机读写
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}

	//读文件
	fseek(pf, 2, SEEK_CUR);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	ch = fgetc(pf);
	printf("%c\n", ch);

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

	//关闭文件
	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

rewind

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

void rewind(FILE* stream);
1

//文件的随机读写
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}

	//读文件
	fseek(pf, 2, SEEK_CUR);
	int ch = fgetc(pf);
	printf("%c\n", ch);
	ch = fgetc(pf);
	printf("%c\n", ch);

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

	rewind(pf);
	a = ftell(pf);
	printf("%d\n", a);//输出当前偏移量的位置

	//关闭文件
	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

8.文本文件和二进制文件

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。
数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在内存中是怎么存储的？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

例：

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

以二进制的形式写入

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

	return 0;
}
1
2
3
4
5
6
7
8
9
10

• 文本文件看不懂二进制，显示的是乱码（文件中放的是二进制）
  
• 可以在VS中查看（显示方式为十六进制类型）
• 是不是二进制文件需要看它存放的是不是二进制数据。
  

9.文件读取结束的判定

在读取文件过程中，不能用feof函数的返回值直接用来判断文件是否结束。
而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件结尾结束。

1. 文本文件读取是否成功，判断返回值是否为EOF(fgetc)，或者NULL(fgets).
   fgetc判断是否为EOF
   fgets判断返回值是否为NULL
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数
   fread判断返回值是否小于实际要读的个数。

文本文件例子

#include
#include

int main()
{
	int c;//注意：int，非字符串，要求处理EOF
	FILE* fp = fopen("test.txt", "r");
	if (!fp)
	{
		perror("File opening failed");
		return EXIT_FAILURE;
	}
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((c = fgetc(fp)) != EOF)//标准c T/O读取文件循环
	{
		putchar(c);
	}
    printf("\n");
	//判断是什么原因结束的
	if (ferror(fp))//读取失败结束
		puts("I/O error when reading");
	else if (feof(fp))//遇到文件末尾结束
		puts("End of file reached successfully");
	fclose(fp);
	fp = 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

二进制文件例子

enum { SIZE = 5 };
int main(void)
{
	double a[SIZE] = { 1.,2.,3.,4.,5. };
	FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式
	fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组
	fclose(fp);
	double b[SIZE];
	fp = fopen("test.bin", "rb");
	size_t ret_code = fread(b, sizeof * b, SIZE, fp); // 读 double 的数组
	if (ret_code == SIZE) {
		puts("Array read successfully, contents: ");
		for (int n = 0; n < SIZE; ++n) printf("%f ", b[n]);
		putchar('\n');
	}
	else { // error handling
		if (feof(fp))
			printf("Error reading test.bin: unexpected end of file\n");
		else if (ferror(fp)) {
			perror("Error reading test.bin");
		}
	}
	fclose(fp);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

10.文件缓冲区

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

• 提高效率

当我们打开一个文件向文件写入数据，该数据会存储到硬盘上，而每次存储都需要经过操作系统，当我们频繁地向硬盘存入数据时，操作系统被使用的次数也就会提高，这使得效率很低。当我们将传入的数据事先放到缓冲区，在缓冲区满后，在经过操作系统传入硬盘，操作系统被使用的次数就会降低，就会大大提高效率。

• 当缓冲区遇到"\n"、强制刷新"fflish()"、关闭文件都会把数据传入到硬盘中。
  

#include 
#include 
//VS2019 WIN11环境测试

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 此时文件中没有数据
  
• （fflush）刷新缓冲区后文件中有了数据
  这里可以得出一个结论：

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