超详细C语言文件操作，学完对文件了解更进一步_c语言文件操作函数总结

什么是文件

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

程序文件

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

数据文件

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

文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用
文件名包含3部分：文件路径+文件名主干+文件后缀
例如：c:\code\test.txt

文件的打开和关闭

文件指针

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

struct _iobuf {
        char *_ptr;
        int   _cnt;
        char *_base;
        int   _flag;
        int   _file;
        int   _charbuf;
        int   _bufsiz;
        char *_tmpfname;
       };
typedef struct _iobuf FILE;
FILE* pf;//文件指针变量
1
2
3
4
5
6
7
8
9
10
11
12

每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不用关系细节
通过文件指针变量能够找到与它相关联的文件

文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束只会就应该关闭文件

filename是打开文件名，mode是以什么方式打开文件。

stream是关闭文件指针。

打开方式

int main()
{	//打开文件
	FILE* pf=fopen("text.txt","w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//其他操作
	
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

文件的顺序读写

fputc

写一个字符到文件里去

int main()
{
	//以写的方式打开文件
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写数据
	fputc('c', 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

fgetc

从文件里得到一个字符，返回类型是int。

int main()
{
	//以读的方式打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读数据
	int 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

fputs

写一串字符到文件里去
str是所指的字符串地址

int main()
{
	//以写的方式打开文件
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写一串数据
	fputs("abcdef", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;

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

fgets

从文件里得到num个字符放到指针str里，注意实际上只会得到num-1个字符，因为后面会补充一个’\0’

int main()
{
	//以读的方式打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写数据
	char str[10] = { 0 };
	fgets(str, 7, pf);//读7个字符，实际上只会读6个字符，后面会增加个'\0'
	//打印数据
	puts(str);
	//关闭文件
	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

fprintf

把格式化的数据写到文件里

注意和printf函数对比，可以先写printf的形式

struct s
{
	char name[20];
	int age;
	float scroe;
};


int main()
{
	struct s peo = { "zhangsan",20,90.5f };
	//以写的方式打开文件
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写数据
	fprintf(pf,"%s %d %f", peo.name, peo.age, peo.scroe);
	//关闭文件
	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

从文件里读取格式化的数据

注意和scanf对比，可以先写scanf格式

struct s
{
	char name[20];
	int age;
	float scroe;
};


int main()
{
	struct s str = {0};
	//以读的方式打开文件
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读数据
	fscanf(pf, "%s %d %f", str.name, &(str.age), &(str.scroe));
	printf("%s %d %f", str.name, str.age, str.scroe);
	//关闭文件
	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

fwrite

把数据以二进制的形式写到文件里
ptr是要写的数据的地址
size要写的数据有多大
count每次写几个数据
stream所指向的文件指针

struct s{
	char name[20];
	int age;
	float scroe;
};

int main()
{
	struct s peo = { "zhangsan",20,90.5f };

	//以二进制形式写的方式打开文件
	FILE* pf = fopen("text.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//以二进制输出数据
	fwrite(&peo, sizeof(peo), 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

fread

和上述反着来的

struct s
{
	char name[20];
	int age;
	float scroe;
};


int main()
{
	struct s peo = {0};

	//以二进制读的方式打开文件
	FILE* pf = fopen("text.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读数据
	fread(&peo, sizeof(peo), 1, pf);
	printf("%s %d %f", peo.name, peo.age, peo.scroe);
	//关闭文件
	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

对比一组函数

scanf,fscanf,sscanf
printf,fprintf,sprintf

scanf 是针对标准输入的格式化输入语句（在控制台得到格式化的数据）
printf 是针对标准输出的格式化输出语句 （把格式化的数据输出到控制台）

fscanf 是针对所有输入流的格式化输入语句（从文件中得到格式化的数据）
fprintf 是针对所有输出流的格式化输出语句（把格式化的数据输出到文件中）

sprintf 把一个格式化的数据转化为字符串
sscanf 从一个字符串中转化一个格式化数据

struct s
{
	char name[20];
	int age;
	float scroe;
};
int main()
{
	struct s peo = { "zhangsan",20,90.5f };
	struct s tmp = { 0 };
	char arr[100] = { 0 };
	sprintf(arr, "%s %d %f", peo.name, peo.age, peo.scroe);
	printf("%s\n", arr);

	sscanf(arr, "%s %d %f", tmp.name, &(tmp.age), &(tmp.scroe));
	printf("%s %d %f\n", tmp.name, tmp.age, tmp.scroe);

	
	return 0;
}

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

文件的随机读写

fseek

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

ftell

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

rewbind

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

int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读数据
	int ch=fgetc(pf);
	printf("%c\n", ch);

	//重新定义文件指针的位置
	fseek(pf, 2, SEEK_SET);
	ch = fgetc(pf);
	printf("%c\n", ch);

	fseek(pf, -1, SEEK_END);
	ch = fgetc(pf);
	printf("%c\n", ch);
	//返回文件指针相当于起始位置的偏移量
	printf("%d\n", ftell(pf));

	//让文件指针的位置回到文件的起始地址
	rewind(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
18
19
20
21
22
23
24
25
26
27
28
29
30
31

文本文件和二进制文件

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

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

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

文件读取结束的判定

被错误使用的feof

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

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

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

文本文件

int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (!pf)
	{
		perror("fopen");
		return 1;
	}
	int ch = 0
	while ((ch = fgetc(pf)) != EOF)
	{
		putchar(ch);
	}
	printf("\n");
	if (feof(pf))
	{
		printf("End of file reached successfully\n");
	}
	else if (ferror(pf))
	{
		printf("I/0 error when reading\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

二进制文件

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
25