文件操作

最新推荐文章于 2024-09-05 16:18:04 发布

wangchen_0

最新推荐文章于 2024-09-05 16:18:04 发布

阅读量844

点赞数 18

文章标签： c语言

本文链接：https://blog.csdn.net/wangchen_0/article/details/140788788

版权

1.为什么使用文件

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

2.什么是文件

磁盘（硬盘）上的文件是文件。

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

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

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

本文讨论的是数据文件。

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

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

根据数据的组织形式，数据文件被称为文本文件或者⼆进制文件。数据在内存中以⼆进制的形式存储，如果不加转换的输出到外存的文件中，就是⼆进制文件。如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

数据在文件中的存储：字符⼀律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

在vs上打开二进制文件：

首先源文件现有项添加

然后右击所选文件打开方式

#include <stdio.h>
int main()
{
	int a = 10000;
	FILE* pf = fopen("test.txt", "wb");
	fwrite(&a, 4, 1, pf);
	fclose(pf);
	pf = NULL;
	return 0;

}

该代码通过上述操作得到10000的二进制存储

4.文件的打开和关闭

在 C 语言中， FILE 是一个结构体类型，用于表示文件信息。文件指针（ FILE * ）是指向 FILE 结构体的指针，通过它可以对文件进行操作。当使用标准的 C 语言文件操作函数（如 fopen 、 fclose 、 fread 、 fwrite 等）时，会返回或需要一个文件指针作为参数，以指定要操作的文件。

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

//打开文件
FILE * fopen ( const char * filename, const char * mode );


//关闭文件
int fclose ( FILE * stream );

mode表示文件的打开模式，在 C 语言中，文件打开模式用于指定文件的打开方式和操作权限，常见的文件打开模式有以下几种：

1.  "r"  ：只读模式。打开一个文本文件用于读取（为了输入数据），如果文件不存在则打开失败。
2.  "w"  ：只写模式。打开一个文本文件用于写入（输出数据），如果文件不存在则创建新文件，如果文件已存在则清空文件内容。
3.  "a"  ：追加模式。打开一个文本文件用于在文件末尾追加内容，如果文件不存在则创建新文件。
4.  "rb"  ：以二进制只读模式打开文件。
5.  "wb"  ：以二进制只写模式打开文件。
6.  "ab"  ：以二进制追加模式打开文件。
7.  "r+"  ：读写模式。打开一个文本文件用于读取和写入，文件必须存在。
8.  "w+"  ：读写模式。打开一个文本文件用于读取和写入，如果文件不存在则创建新文件，如果文件已存在则清空文件内容。
9.  "a+"  ：读写模式。打开一个文本文件用于读取和在文件末尾追加内容，如果文件不存在则创建新文件。

10.“rb+”：读写模式。为了读和写打开一个二进制文件，文件不存在则失败。

11.“wb+”：读写模式。为了读和写，新建一个二进制文件，如果文件不存在则新建一个文件。

12.“ab+”：读写模式。打开一个二进制文件，在文件尾进行读和写，如果文件不存在则建一个新文件

5.文件顺序读写

顺序读写函数如下：

fgetc：字符输入函数。适用于所有输入流。

fputc：字符输出函数。适用于所有输出流

fgets：字符串输入函数。适用于所有输入流

fputs：字符串输出函数。适用于所有输出流

fscanf：格式化输入函数。适用于所有输入流

fprintf：格式化输出函数。适用于所有输出流

fread：二进制输入。适用于文件

fwrite：二进制输出。适用于文件

上面说的适用于所有输入流⼀般指适用于标准输入流和其他输入流（如文件输入流）；所有输出流一般指适用于标准输出流和其他输出流（如文件输出流）。标准输入流stdin 标准输出流stdout

//成功读取，返回的是字符的ASCLL值，读取失败返回EOF（-1）
int fgetc ( FILE * stream );
int fputc ( int character, FILE * stream );stream是指向要写入的文件流的指针
char * fgets ( char * str, int num, FILE * stream );
int fputs ( const char * str, FILE * stream );
int fscanf ( FILE * stream, const char * format, ... );
int fprintf ( FILE * stream, const char * format, ... );
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

在此处打开文件：

（1）fputc应用：用于向指定的文件流输出一个字符。

//int fputc ( int c, FILE * stream );c是要输出的字符，以整形形式传递，stream是指向要写入的文件流
                                    //的指针              
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");//文件流，写入文件test.txt
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	//写文件
	fputc('a', pf);//pf是文件指针，
	fputc('b', pf);
	fputc('c', pf);

	char ch = 0;
	for (ch = 'a'; ch <= 'z'; ch++)
	{
		fputc(ch, pf);
	}

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

（2）fgetc应用：用于从指定的文件流中读取一个字符

//int fgetc ( FILE * stream );
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == null)
	{
		perror(pf);
		return 1;
	}
	//读文件,此处读的是上一个代码写入的字符
	int i = fgetc(pf);
	printf("%c\n", i);

	i = fgetc(pf);
	printf("%c\n", i);

	i = fgetc(pf);
	printf("%c\n", i);

	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c", ch);
	}
	//关闭文件
	fclose(pf);
	pf = null;
	return 0;
}

（3）fputs应用：用于向指定的文件流写入一个字符串，字符结束符\0不会被写入

//int fputs ( const char * str, FILE * stream );
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(pf);
		return 0;
	}
	//写文件
	
	fputs("hellow world\n", pf);//写入pf指向的文件
	fputs("hellow world\n", pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

（4）fgets应用：用于从指定的文件流中读取一行字符串。

//char * fgets ( char * str, int num, FILE * stream );
//fgets只读一行内容
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	//读文件
	const char arr[20] = { 0 };
	fgets(arr, 10, pf);
	printf("%s\n", arr);//如果数组空间充足，会把\n读出，写进数组
	while (fgets(arr, 10, pf) != NULL)
	{
		printf("%s", arr);//打印所有内容，自动换行，因为数组中有\n
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

printf  函数用于将格式化的数据输出到标准输出（通常是屏幕）。
sprintf  函数则把格式化的数据输出到指定的字符数组中。
fprintf  函数将格式化的数据输出到指定的文件流。
它们的格式控制字符串的规则基本一致，但输出的目标有所不同。

例如，（1）printf("Hello, World!\n");  会在屏幕上输出 "Hello, World!" 并换行。
（2）char str[100]; sprintf(str, "The number is %d", 5);  会将格式化后的字符串 "The number is 5" 存储到字符数组 str  中。
（3）FILE *fp; fp = fopen("output.txt", "w"); fprintf(fp, "This is a line of text.\n"); fclose(fp);  这段代码会将指定的文本写入到名为 "output.txt" 的文件中。

（5）fprintf ：

//int fprintf ( FILE * stream, const char * format, ... );
struct S 
{
	int n;
	char i[20];
	float a;
}s;
int main()
{
	//打开文件
	struct S s = { 5,"张三",20.65 };
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	fprintf(pf, "%d %s %f", s.n, s.i, s.a);

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

sprintf：

struct S 
{
	int n;
	char i[20];
	float a;
}s;

int main()
{
	int buf[200] = { 0 };
	struct S s = { 5,"zhangsan",50.24f };
	sprintf(buf, "%d %s %f", s.n, s.i, s.a);//将数据转化为字符串输出的字符数组中
	printf("按照字符串形式打印：%s\n", buf);
	return 0;
}

scanf 、 sscanf 和 fscanf 是 C 语言标准库中的输入函数。这三个函数的格式控制字符串的用法基本相同，但输入来源不同。

fscanf  函数用于从指定的文件流中读取格式化的数据。
scanf  函数用于从标准输入（通常是键盘）读取格式化的数据。
sscanf  函数则从指定的字符串中读取格式化的数据。

（6）fscanf：

//在已经==已经把s中的内容放在文件test.txt的前提下
//int fscanf ( FILE * stream, const char * format, ... );

struct S
{
	int n;
	char i[20];
	float a;
}s;
int main()
{
	struct S s = { 5,"张三",20.65 };
	//想从文件test.txt读出的数据放在s中
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	//读文件
	fscanf(pf, "%d %s %f", &(s.n), s.i, &(s.a));//从指定的文件中读取数据

	printf("%d %s %f", s.n, s.i, s.a);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

sscanf：


struct S 
{
	int n;
	char i[20];
	float a;
}s;

int main()
{
	int buf[200] = { 0 };
	struct S s = { 5,"zhangsan",50.24f };
	sprintf(buf, "%d %s %f", s.n, s.i, s.a);
	printf("按照字符串形式打印：%s\n", buf);

	struct S t = { 0 };
	sscanf(buf, "%d %s %f", &(t.n), t.i, &(t.a));//从指定的字符串中读取数据，将字符串还原
	printf("按照格式打印：%d %s %f", t.n, t.i, t.a);
	return 0；
}

我们在上面说过的顺序读写函数都适用于所有输入（输出）流，下面代码1的形式就是文件输出流形式，输出到pf指定的文件中。代码2就是标准输出流的形式，通常输出到屏幕上

代码1
int main()
{
    //......
	fputc('a', pf);
    //......
	return 0;
}

代码2
int main()
{
	fputc('a', stdout);
	return 0;
}

struct S 
{
	int n;
	char i[20];
	float a;
}s;
int main()
{
	//打开文件
	struct S s = { 5,"张三",20.65 };
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	fprintf(stdout, "%d %s %f", s.n, s.i, s.a);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

不同与上面介绍的函数，fread和fwrite专门适用于文件输出（入）流，

（7）fwrite的作用是将指定数量的数据以二进制的方式从指定的内存区域写入到给定的文件指针所关联的文件中

fwrite 函数返回实际写入的完整数据项的数量，如果返回值小于 nmemb ，则表示发生了错误。

//size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
//-  ptr  是指向要写入数据的指针。
//-  size  是每个数据项的大小（以字节为单位）。
//-  nmemb  是要写入的数据项的数量。
//-  stream  是指向  FILE  结构的指针，指定要写入的文件。
 
int main()
{
	int arr[] = {1,2,3,4,5};

	FILE* pf = fopen("test.txt", "wb");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}

	//写数据
	int sz = sizeof(arr) / sizeof(arr[0]);
	fwrite(arr, sizeof(arr[0]), sz, pf);

	fclose(pf);
	pf = NULL;
	return 0;
}

二进制形式输出

fread的作用是从指定的文件指针关联的文件中读取指定数量的数据，并将这些数据存储到指定的内存区域

（8） fread 函数返回实际读取的完整数据项的数量，如果返回值小于 nmemb ，可能表示已到达文件末尾或发生了错误。

//size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
//-  ptr  是指向用于存储读取数据的内存缓冲区的指针。
//-  size  是每个数据项的大小（以字节为单位）。
//-  nmemb  是要读取的数据项的数量。
//-  stream  是指向  FILE  结构的指针，指定要读取的文件。
int main()
{
	int arr[] = { 1,2,3,4,5 };

	FILE* pf = fopen("test.txt", "wb");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}

	//读数据
	fread(arr, sizeof(arr[0]), 5, pf);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

二进制形式读取，可以读懂我们看不懂的乱码

对于该乱码，我们右击源文件，在现有项中打开指定文件，再右击该文件，在打开方式中选择二进制编辑器就可以看到二进制形式的输出结果了。

6.文件随机读写

(1) 在 C 语言标准库中， fseek 函数用于在文件中移动文件指针。
其函数原型通常为：

 int fseek(FILE *stream, long offset, int whence) 
返回值：成功返回 0 ，失败返回非零值。
-  stream ：指向文件流的指针。
-  offset ：要移动的字节数，可以是正数、负数或零。
-  whence ：指定起始位置，它有以下几种取值：
-  SEEK_SET ：文件开头。
-  SEEK_CUR ：当前位置。
-  SEEK_END ：文件末尾。

fseek 函数的主要作用包括：
1. 随机访问文件：可以直接将文件指针移动到指定位置，从而实现对文件的随机读取或写入。
2. 重新定位读取或写入位置：例如，如果需要从文件的中间开始读取数据，就可以使用 fseek 先将文件指针移动到相应位置。

//text.txt文件中是hellow world
int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}

	int ch = fgetc(pf);
	printf("%c\n", ch);//a
	fseek(pf, 9, SEEK_SET);
	ch = fgetc(pf);
	printf("%c\n", ch);//r
	fclose(pf);
	pf = NULL;
	return 0;
}

（2）在 C 语言标准库中， ftell 函数用于获取文件指针相对于文件起始位置的偏移量。
其函数原型通常为：

 long ftell(FILE *stream) ;

ftell 函数的主要作用是获取当前文件指针在文件中的位置，返回值是以字节为单位的偏移量。如果获取位置失败，会返回 -1L 。
这个函数常用于以下场景：
1. 了解文件的读取或写入进度。
2. 实现文件的分段处理或恢复上次的处理位置。

//text.txt文件中是hellow world
int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	fseek(pf, -5, SEEK_END);
	printf("%d\n", ftell(pf));//7
	return 0;

（3）在 C 语言标准库中， rewind 函数用于将文件指针重新定位到文件的起始位置。
其函数原型通常为：

 void rewind(FILE *stream)；

rewind 函数的主要作用是简单而有效地将文件指针重置到文件的开头，以便重新读取文件或者从头开始进行写入操作。它会清除文件指针的错误和 EOF 标记。
在实际编程中，如果需要多次读取同一个文件，或者在某些操作后需要回到文件开头重新开始处理，就可以使用 rewind 函数。

int main()
{
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror(pf);
		return 1;
	}
	fseek(pf, -5, SEEK_END);
	printf("%d\n", ftell(pf));//7

	rewind(pf);
	int n = fgetc(pf);
	printf("%c\n", n);//h
	return 0;
}

7.文件读取结束的判定

在 C 语言标准库中， feof 函数用于检测文件指针是否已到达文件末尾。
其函数原型通常为：

int feof(FILE *stream)；

feof 函数的主要作用文件读取结束的时候，判断是读取结束的原因是否是：遇到文件尾结束。在文件读取过程中，不能用feof函数的返回值直接来判断文件的是否结束。

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

例如：

fgetc：如果读取成功，则返回的是读取到字符的ASCLL值，如果读取失败，读取过程中遇见文件末尾，或者发生失败，返回EOF

fgets：如果读取成功，则返回的是存储读取到的字符串的字符数组的地址，如果读取失败，读取过程中遇见文件末尾，或者发生失败，返回NULL

（2）二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
在实际编程中，常常用于循环读取文件的操作，以便在到达文件末尾时能够正确结束读取。

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

	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)
	{
		printf("%c", ch);
	}
	if (feof(pf))
	{
		printf("遇到文件末尾，读取正常结束\n");
	}
	else if (ferror(pf))
	{
		perror(pf);
	}
	return 0;
}

wangchen_0

关注

18
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
文件操作

磁盘（硬盘）上的文件是文件。但是在程序设计中，我们⼀般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。程序文件：程序文件包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows 环境后缀为.exe）。数据文件：文件的内容不⼀定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。本文讨论的是数据文件。⼀个文件要有⼀个唯⼀的文件标识，以便用户识别和引用。
复制链接

扫一扫