C语言C-语言文件操作全解析从基础到进阶

JAY.LIN 收录于 C

2025-09-19 约 9219 字预计阅读 19 分钟

https://bing.ee123.net/img/rand?artid=151142287

【C语言】C 语言文件操作全解析：从基础到进阶

一、为什么使用文件

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

数据是存储在内存中的，当程序退出之后申请到的内存就回收了，数据就丢失了，就像上面图中我们为a开辟了空间，只要不退出a的空间就会一直存在，但是退出这个程序a的空间就被回收了，如果我们将数据存储在文件中，就可以将数据“永久”保存，只要硬件不损坏，就一直存在。

二、什么是文件

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

1、程序文件

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

我们可以打开我们的C盘或者D盘我们存放代码的文件中就可以看到。

2、数据文件

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

3、文件名

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

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

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

一个数据在文件中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节。

在为大家通俗解释一下：用记事本打开.c为后缀的文件就是文本文件，我们可以看懂；用记事本打开.exe为后缀的文件就是二进制文件，我们看不懂。

下面为大家演示一段代码：

#include<stdio.h>
int main()
{
	int a = 10000;
	FILE* pf = fopen("test.txt", "wb");
	fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
	//fwrite是写入文件，这段代码表示写入一个数据，一个数据占四个字节
	fclose(pf);
	//fclose是关闭文件
	pf = NULL;
	return 0;
}

我们先运行代码然后按照下面的指示打开文件：

然后我们就可以看到我们多出来一个txt的文件，接着按照下述方法操作就可以在VS上打开二进制文件：

我们可以看到我们的10000被按照小端字节形式存储起来了。

四、流和文件指针

1、流和标准流

1.1、流

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

1.2、标准流

那为什么我们从键盘输入数据，向屏幕上输出数据，并没有打开流呢？
那是因为C语言程序在启动的时候，默认打开了3个流：

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

2、文件指针

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

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

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

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

一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。下面我们可以创建一个FILE*的指针变量：

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

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

比如：

五、文件的打开和关闭

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

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

ANSI C规定使用 fopen 函数来打开文件， fclose 来关闭文件。

1、fopen

//打开文件
FILE * fopen ( const char * filename, const char * mode );
功能：fopen 函数是用来打开参数 filename 指定的文件，同时将打开的文件和一个流进行关联，后续对流的操作是通过 fopen 函数返回的指针来维护。具体对流（关联的文件）的操作是通过参数 mode 来指定的。
参数：
filename：表示被打开的文件的名字，这个名字可以绝对路径，也可以是相对路径。
mode：表示对打开的文件的操作方式，具体见下面的表格。
返回值：
若文件成功打开，该函数将返回一个指向 FILE 对象的指针，该指针可用于后续操作中标识对应的流。
若打开失败，则返回 NULL 指针，所以一定要 fopen 的返回值做判断，来验证文件是否打开成功。

当前程序下没有这个文件我们用a打开会报错（用perror打印错误信息），但是用w打开则会帮我们下新建一个文件。

我们可以看到他的大小是0KB，因为我们没有写入东西

代码演示：

#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "r"); //以“r”的形式打开⽂件，如果⽂件不存在，则打开失败
    if (pf == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	printf("打开⽂件成功，可以对⽂件进⾏操作\n");
	//不再使⽤⽂件时，需要关闭⽂件 

	return 0;
}

2、fclose

int fclose ( FILE * stream );
功能：关闭参数 stream 关联的文件，并取消其关联关系。与该流关联的所有内部缓冲区均会解除关联并刷新：任何未写入的输出缓冲区内容将被写入，任何未读取的输入缓冲区内容将被丢弃。
参数：
stream：指向要关闭的流的 FILE 对象的指针
返回值：成功关闭 stream 指向的流会返回 0，否则会返回 EOF。

代码演示：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data,txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	printf("打开文件成功，可以对文件进行操作\n");

	//读取文件

	//关闭文件
	fclose(pf);
	//这里fclose完之后他是一个野指针，我们需要将pf再次置为空指针
	pf = NULL;
	return 0;
}

六、文件的顺序读写（很重要）

在进行文件读写的时候，会涉及下面这些函数，我们一一为大家介绍：

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

1、fputc

int fputc ( int character, FILE * stream );
功能：将参数 character 指定的字符写入到 stream 指向的输出流中，通常用于向文件或标准输出流写入字符。在写入字符之后，还会调整指示器。字符会被写入流内部位置指示器当前指向的位置，随后该指示器自动向前移动一个位置。
参数：
character：被写入的字符
stream：是一个 FILE* 类型的指针，指向了输出流（通常是文件流或 stdout）。
返回值：
成功时返回写入的字符（以 int 形式）。
失败时返回 EOF（通常是 -1），错误指示器会被设置，可通过 ferror() 检查具体错误。

代码演示：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fputc('a', pf);
	fputc('b', pf);
	fputc('c', pf);
	fputc('d', pf);

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

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写字符到标准输出流(屏幕上)
	fputc('a', stdout);
	fputc('b', stdout);
	fputc('c', stdout);
	fputc('d', stdout);

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

这次运行代码就会在屏幕上直接打印。

当然也可以在他里面进行循环操作打印：

#include<stdio.h>
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	int i = 0;
	for (i = 'a'; i <= 'z'; i++)
	{
		fputc(i, pf);
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

2、fgetc

int fgetc ( FILE * stream );
功能：从参数 stream 指向的流中读取一个字符。函数返回的是文件指示器当前指向的字符，读取这个字符之后，文件指示器自动前进到下一个字符。
参数：
stream：FILE* 类型的文件指针，可以是 stdin，也可以是其他输入流的指针。如果是 stdin 就从标准输入流读取数据。如果是文件流指针，就从文件读取数据。
返回值：
成功时返回读取的字符（以 int 形式）。
若调用时流已处于文件末尾，函数返回 EOF 并设置流的文件结束指示器（feof）。
若发生读取错误，函数返回 EOF 并设置流的错误指示器（ferror）。

代码演示：

//我们就写代码，来读取前⾯test.txt⽂件中的前10个字符 
#include <stdio.h>
int main()
{
	FILE* fp = fopen("test.txt", "r");
	if (fp == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		int c = fgetc(fp);
		fputc(c, stdout); //使⽤fputc在标准输出流上打印字符 
	}

	//不再使⽤⽂件时，需要关闭⽂件 
	fclose(fp);
	fp = NULL; //将指针置为NULL,避免成为野指针。 
	return 0;
}

3、feof和ferror

我们前面学过 EOF 是 end of file 就是文件结束标志的意思。

int feof ( FILE * stream );
//检测stream指针指向的流是否遇到文件末尾

int ferror ( FILE * stream );
//检测stream指针指向的流是否发生读/写错误
如果在读取文件的过程中，遇到了文件末尾，文件读取就会结束。这时读取函数会在对应的流上设置一个文件结束的指示符，这个文件结束指示符可以通过 feof 函数检测到。如果 feof 函数检测到文件结束指示符已经被设置，则返回非 0 的值，如果没有设置则返回 0。
如果在读 / 写文件的过程中，发生了读 / 写错误，文件读取就会结束。这时读 / 写函数会在对应的流上设置一个错误指示符，这个错误指示符可以通过 ferror 函数检测到。如果 ferror 函数检测到错误指示符已经被设置，则返回非 0 的值，如果没有设置则返回 0。

测试feof函数：

#include <stdio.h>
//假设test.txt⽂件中存放abcdef 
int main()
{
	FILE* fp = fopen("test.txt", "r");
	if (fp == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
		{
		int c = fgetc(fp);
		if (c == EOF)
		{
			if (feof(fp))
				printf("遇到⽂件末尾了\n");
			else if (ferror(fp))
				printf("读取发⽣了错误\n");
		}
		else
		{
			fputc(c, stdout); //使⽤fputc在标准输出流上打印字符 
		}
	}
	//不再使⽤⽂件时，需要关闭⽂件 
	fclose(fp);
	fp = NULL; //将指针置为NULL,避免成为野指针。 
	return 0;
}

测试ferror函数：

#include <stdio.h>
//以写的形式打开⽂件后，再去读⽂件，就会发⽣错误 
int main()
{
	FILE* fp = fopen("test.txt", "w");
	if (fp == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	int c = fgetc(fp);//读⽂件 
	if (c == EOF)
	{
		if (feof(fp))
			printf("遇到⽂件末尾了\n");
		else if (ferror(fp))
		{
			printf("读⽂件发⽣了错误\n");
		}
	}
	else
	{
		fputc(c, stdout); //使⽤fputc在标准输出流上打印字符 
		
	}
	//不再使⽤⽂件时，需要关闭⽂件 
	fclose(fp);
	fp = NULL; //将指针置为NULL,避免成为野指针。 
	return 0;
}

4、fputs

int fputs ( const char * str, FILE * stream );
功能：将参数 str 指向的字符串写入到参数 stream 指定的流中（不包含结尾的空字符 \0），适用于文件流或标准输出（stdout）。
参数：
str：str 是指针，指向了要写入的字符串（必须以 \0 结尾）
stream：是一个 FILE* 的指针，指向了要写入字符串的流。
返回值：
成功时返回非负整数。
失败时返回 EOF（-1），同时会设置流的错误指示器，可以使用 ferror() 检查错误原因。

代码演示：

#include <stdio.h>
int main()
{
	FILE* fp = fopen("test.txt", "w");
	if (fp == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	int i = 0;
	fputs("abc\0def", fp);
	fputs("hehe", fp);
	//不再使⽤⽂件时，需要关闭⽂件 
	fclose(fp);
	fp = NULL; //将指针置为NULL,避免成为野指针。 
	return 0;
}

5、fgets

char * fgets ( char * str, int num, FILE * stream );
功能：从 stream 指定输入流中读取字符串，至读取到换行符、文件末尾（EOF）或达到指定字符数（包含结尾的空字符 \0），然后将读取到的字符串存储到str指向的空间中。
参数：
str：是指向字符数组的指针，str指向的空间用于存储读取到的字符串。
num：最大读取字符数（包含结尾的 \0，实际最多读取 num-1 个字符）。
stream：输入流的文件指针（如文件流或 stdin）。
返回值：
成功时返回 str 指针。
若在尝试读取字符时遇到文件末尾，则设置文件结束指示器，并返回 NULL，需通过 feof() 检测。
若发生读取错误，则设置流错误指示器，并返回 NULL，通过 ferror() 检测。

代码演示：

#include <stdio.h>
int main()
{
	FILE* fp = fopen("test.txt", "r");
	if (fp == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	char arr1[] = "*************";
	fgets(arr1, sizeof(arr1), fp);

	char arr2[] = "*************";
	fgets(arr2, sizeof(arr1), fp);
	//不再使⽤⽂件时，需要关闭⽂件 
	fclose(fp);
	fp = NULL; //将指针置为NULL,避免成为野指针。 
	return 0;
}

6、fprintf

int fprintf ( FILE * stream, const char * format, ... );
//类比printf函数学习
功能：fprintf 是将格式化数据写入指定文件流的函数。它与 printf 类似，但可以输出到任意文件（如磁盘文件、标准输出、标准错误等），而不仅限于控制台。
参数：
stream：指向 FILE 对象的指针，表示要写入的文件流（如 stdout、文件指针等）。
format：格式化字符串，包含要写入的文本和格式说明符（如 %d、%s 等）。
...：可变参数列表，提供与格式字符串中说明符对应的数据。
返回值：
成功时，返回写入的字符总数（非负值）。
失败时，先设置对应流的错误指示器，再返回负值，可以通过 ferror() 来检测。

代码演示：

#include <stdio.h>
struct Stu
{
	char name[30];
	int age;
	float score;
};
int main()
{
	struct Stu b = { "zhangsan", 20, 85.5f };
	FILE* fp = fopen("test.txt", "w");
	if (fp == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	fprintf(fp, "%s %d %.1f", b.name, b.age, b.score);
	//不再使⽤⽂件时，需要关闭⽂件 
	fclose(fp);
	fp = NULL; //将指针置为NULL,避免成为野指针。 
	return 0;
}

如果我们将fprintf中的fp改为stdout将会直接给信息打印到屏幕上。

7、fscanf

int fscanf ( FILE * stream, const char * format, ... );
//类比scanf函数来学习
功能：fscanf 是从指定文件流中读取格式化数据的函数。它类似于 scanf，但可以指定输入源（如文件、标准输入等），而不仅限于控制台输入。适用于从文件解析结构化数据（如整数、浮点数、字符串等）。
参数：
stream：指向 FILE 对象的指针，表示要读取的文件流（如 stdin、文件指针等）。
format：格式化字符串，定义如何解析输入数据（如 %d、%f、%s 等）。
...：可变参数列表，提供存储数据的变量地址（需与格式字符串中的说明符匹配）。
返回值：
成功时，函数返回成功填充到参数列表中的项数。该值可能与预期项数一致，也可能因以下原因少于预期（甚至为零）：
格式和数据匹配失败；
读取发生错误；
到达文件末尾（EOF）。
如果在成功读取任何数据之前发生：
发生读取错误，会在对应流上设置错误指示符，则返回 EOF。
到达文件末尾，会在对应流上设置文件结束指示符，则返回 EOF。

代码演示：

#include <stdio.h>
struct Stu
{
 char name[30];
 int age;
 float score;
};
int main()
{
 struct Stu s = { 0 };
 FILE* fp = fopen("test.txt", "r");
 if (fp == NULL)
 {
 perror("fopen\n");
 return 1;
 }
 fscanf(fp, "%s %d %f", s.name, &(s.age), &(s.score));//按照格式读取数据 
 fprintf(stdout, "%s %d %.1f\n", s.name, s.age, s.score);//打印数据在stdout
上 
 //不再使⽤⽂件时，需要关闭⽂件 
 fclose(fp);
 fp = NULL; //将指针置为NULL,避免成为野指针。 
 return 0;
}

8、fwrite

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
功能：函数用于将数据块写入 stream 指向的文件流中，是以二进制的形式写入的。
参数：
ptr：指向要写入的数据块的指针。
size：要写入的每个数据项的大小（以字节为单位）。
count：要写入的数据项的数量。
stream：指向 FILE 类型结构体的指针，指定了要写入数据的文件流。
返回值：返回实际写入的数据项数量。如果发生错误，则返回值可能小于 count。
使用注意事项：
需要包含 <stdio.h> 头文件。
在使用 fwrite() 之前，需要确保文件已经以二进制可写方式打开。
fwrite() 通常用于二进制数据的写入，如果写入文本数据，请谨慎处理换行符和编码等问题。

代码演示：

假设要将一组整数写入到文件"data.bin"中：

#include <stdio.h>
int main()
{
	int data[] = { 1, 2, 3, 4, 5 };
	// 打开⽂件 
	FILE* fp = fopen("data.bin", "wb");
	// 检查⽂件是否成功打开 
	if (fp == NULL)
	{
		perror("fopen");
		return -1;
	}
	// 将数据写⼊⽂件 
	if (fwrite(data, sizeof(int), 5, fp) != 5)
	{
		perror("fwrite");
		return -1;

	}
	// 关闭⽂件 
	fclose(fp);
	fp = NULL;
	return 0;
}

9、fread

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
功能：函数用于从 stream 指向的文件流中读取数据块，并将其存储到 ptr 指向的内存缓冲区中。
参数：
ptr：指向内存区域的指针，用于存储从文件中读取的数据。
size：要读取的每个数据块的大小（以字节为单位）。
count：要读取的数据块的数量。
stream：指向 FILE 类型结构体的指针，指定了要从中读取数据的文件流。
返回值：返回实际读取的数据块数量。
使用注意事项：
需要包含 <stdio.h> 头文件。
在使用 fread() 之前，需要确保文件已经以二进制可读方式打开。
ptr 指向的内存区域必须足够大，以便存储指定数量和大小的数据块。
如果 fread() 成功读取了指定数量的数据块，则返回值等于 count；如果读取数量少于 count，则可能已经到达文件结尾或者发生了错误。
在二进制文件读取时，fread() 是常用的函数，但对于文本文件读取，通常使用 fgets() 或 fscanf()。

代码演示：

假设有一个二进制文件"data.bin"，包含一些整数数据，我们将使用fread( )函数读取这些数据：

#include <stdio.h>
int main()
{
	int data[5] = { 0 }; // 假设⽂件中包含 5 个整数数据 
	// 打开⽂件 
	FILE* fp = fopen("data.bin", "rb");
	// 检查⽂件是否成功打开 
	if (fp == NULL) {
		perror("fopen");
		return -1;
	}
	// 从⽂件中读取整数数据块 
	size_t num_read = fread(data, sizeof(int), 5, fp);
	// 检查读取是否成功 
	if (num_read != 5)
	{
		if (feof(fp))
			printf("Reached end of file\n");
		else if (ferror(fp))
			printf("Error reading file\n");
	}
	else
	{
		// 输出读取的数据 
		for (int i = 0; i < 5; i++) {
			printf("Data[%d]: %d\n", i, data[i]);
		}
	}
	// 关闭⽂件 
	fclose(fp);
	return 0;
}

10、对比一组函数

/ /

10.1、sprintf

int sprintf ( char * str, const char * format, ... );
功能：将格式化数据写入字符数组（字符串）。它类似于 printf，但输出目标不是控制台或文件，而是用户指定的内存缓冲区。常用于动态生成字符串、拼接数据或转换数据格式。简而言之就是将格式化的数据转换成一个字符串。
参数：
str：指向字符数组的指针，用于存储生成的字符串（需确保足够大以防止溢出）。
format：格式化字符串，定义输出格式（如 %d、%f、%s 等）。
...：可变参数列表，提供与格式字符串中说明符对应的数据。
返回值：
成功时：返回写入 buffer 的字符数（不包括结尾的空字符 \0）。
失败时：返回负值。

代码演示：

#include <stdio.h>
struct Stu
{
	char name[30];
	int age;
	float score;
};
int main()
{
	struct Stu s = { "zhangsan", 100, 85.5f };
	//将s中的结构数据转换成⼀个字符串 
	char arr[100] = { 0 };
	sprintf(arr, "%s %d %.1f", s.name, s.age, s.score);
	printf("%s\n", arr);
	return 0;
}

10.2、sscanf

int sscanf ( const char * str, const char * format, ...);
功能：从字符串中读取格式化数据。它与 scanf 类似，但输入源是内存中的字符串而非控制台或文件。常用于解析字符串中的结构化数据（如提取数字、分割文本等）。
参数：
str：要解析的源字符串（输入数据来源）。
format：格式化字符串，定义如何解析数据（如 %d、%f、%s 等）。
...：可变参数列表，提供存储数据的变量地址（需与格式字符串中的说明符匹配）
返回值：
成功时：返回成功解析并赋值的参数数量（非负值）。
失败或未匹配任何数据：若输入结束或解析失败，返回 EOF（通常是 -1）。

代码演示：

#include <stdio.h>
struct Stu
{
	char name[30];
	int age;
	float score;
};
int main()
{
	char str[] = "zhangsan 100 85.5";
	struct Stu s = { 0 };
	//从str中的字符串内中解析出格式化的数据，存放在结构体中 
	sscanf(str, "%s %d %f", s.name, &(s.age), &(s.score));
	//打印结构体s中的数据 
	printf("%s %d %.1f\n", s.name, s.age, s.score);
	return 0;
}

总结

七、文件的随机读写

1、fseek

代码演示：

/* fseek example */
#include <stdio.h>
int main()
{
	FILE* pFile;
	pFile = fopen("example.txt", "wb");
	fputs("This is an apple.", pFile);
	fseek(pFile, 9, SEEK_SET);
	fputs(" sam", pFile);
	fclose(pFile);
	return 0;
}

2、ftell

代码演示：

/* ftell example : getting size of a file */
#include <stdio.h>
int main()
{
	FILE* pFile;
	long size;
	pFile = fopen("myfile.txt", "rb");
	if (pFile == NULL)
		perror("Error opening file");
	else
	{
		fseek(pFile, 0, SEEK_END); // non-portable
		size = ftell(pFile);
		fclose(pFile);
		printf("Size of myfile.txt: %ld bytes.\n", size);
	}
	return 0;
}

3、rewind

/* rewind example */
#include <stdio.h>
int main()
{
	int n;
	FILE* pFile;
	char buffer[27];

	pFile = fopen("myfile.txt", "w+");
	for (n = 'A'; n <= 'Z'; n++)
		fputc(n, pFile);
	rewind(pFile);

	fread(buffer, 1, 26, pFile);
	fclose(pFile);
    buffer[26] = '\0';
	printf(buffer);
	return 0;
}

八、文件缓冲区

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

1、fflush

int fflush ( FILE * stream );
功能：强制刷新参数 stream 指定流的缓冲区，确保数据写入底层设备。
对输出流：将缓冲区中未写入的数据立即写入文件。
对输入流：行为由具体实现决定，非 C 语言标准行为（可能清空输入缓冲区）
参数为 NULL 时：刷新所有打开的输出流
参数：
stream：指向文件流的指针（如 stdout、文件指针等）
返回值：成功返回 0，失败返回 EOF
注意事项：
仅对输出流或更新流（最后一次操作为输出）有明确刷新行为
输入流的刷新行为不可移植（如清空输入缓冲区是非标准特性）
程序正常终止（exit）或调用 fclose 时会自动刷新，但程序崩溃时缓冲区数据可能丢失

代码演示：

#include <stdio.h>
#include <windows.h>
//VS2022 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;
}

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

九、更新文件

在文件的打开模式中有三种方式值得注意，分别是: “r+"、“w+"、“a+"，分别是什么意思？

#include <stdio.h>
int main()
{
	FILE* fp = fopen("test.txt", "w+");
	if (fp == NULL)
	{
		perror("fopen for w+");
		return 1;
	}
	//写abcdefghi到⽂件中 
	fputs("abcdefghi", fp);
	//刷新缓冲区，保证数据写⼊⽂件 
	fflush(fp);
	//要读取数据b字符，先定位⽂件指针 
	fseek(fp, 1, SEEK_SET);
	int ch = fgetc(fp);//读取字符 
	printf("%c\n", ch);
	//在b的位置开始写⼊hello 
	fseek(fp, -1, SEEK_CUR);
	//解释：因为前⾯读取⼀个字符后,⽂件指⽰器现在指向了c,需要从当前位置退回⼀个字符 

	fputs("hello", fp);
	//关闭⽂件 
	fclose(fp);
	fp = NULL;
	return 0;
}

十、编程练习：写一个程序拷贝文件

我们首先要自己创建一个data.txt的文件，然后随便输入几个信息如下图所示：

下面是代码的实现：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	FILE* pr = fopen("data.txt", "r");
	if (pr == NULL)
	{
		perror("打开文件失败—r");
		return 1;
	}
	FILE* pw = fopen("data_copy.txt", "w");
	if (pw == NULL)
	{
		perror("打开文件失败—w");
		return 1;
	}
	int ch;
	while (ch = fgetc(pr) != EOF)
	{
		fputc(ch, pw);
	}
	fclose(pw);
	fclose(pr);
	pw = NULL;
	pr = NULL;
	return 0;
}

目录

C语言C-语言文件操作全解析从基础到进阶

【C语言】C 语言文件操作全解析：从基础到进阶

一、为什么使用文件

二、什么是文件

1、程序文件

2、数据文件

3、文件名

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

四、流和文件指针

1、流和标准流

1.1、流

1.2、标准流

2、文件指针

五、文件的打开和关闭

1、fopen

2、fclose

六、文件的顺序读写（很重要）

1、fputc

2、fgetc

3、feof和ferror

4、fputs

5、fgets

6、fprintf

7、fscanf

8、fwrite

9、fread

10、对比一组函数

10.1、sprintf

10.2、sscanf

总结

七、文件的随机读写

1、fseek

2、ftell

3、rewind

八、文件缓冲区

1、fflush

九、更新文件

十、编程练习：写一个程序拷贝文件