C语言文件操作详解

那么一个数据在文件中是如何存储的呢?
字符型一律按照ASCII形式存储，数值型数据既可以安装ASCII形式进行存储，也可以安装二进制形式进行存储。
比如现在有一个整数10000，如果以ASCII码形式输出到硬盘，则硬盘中占用5个字节（每个字符占用一个字节'1' '0' '0' '0' '0'），如果以二进制形式输出到硬盘，则硬盘中占用4个字节（0010 0111 0001 0000）。

二、文件操作

2.1 流和标准流

2.1.1 流

程序的数据需要输出到各种外部设备，也需要从外部设备获取数据，但是不同的外部设备的输⼊输出操作各不相同，为了⽅便程序员对各种设备进⾏⽅便的操作，于是提出了流的概念。

在C程序中，针对文件、画面、键盘等的输入输出都是通过流来操作的。

一般情况下，当需要向流里写入数据或者读取数据，都是需要打开流，然后进行后续操作。

2.1.2 标准流

刚刚提到，当需要向流里写入数据或者读取数据，都是需要打开流，然后进行后续操作，那么为什么在C语言中，我们从键盘中输入数据，向屏幕上输出数据，并没有去打开流呢？

其实是因为C语言在程序启动的时候，就已经默认打开了3个流：

stdin - 标准输入流 --- 在大多数的环境中从键盘输入，例如scanf函数
stdout - 标准输出流 -- 在大多数环境中输出至显示器，例如printf函数
stderr - 标准错误流 -- 在大多数环境相爱，将错误信息输出到显示器界面

得益于默认打开了这三个流，我们才能在使用scanf。printf等函数就可以直接进行输入输出操作。
stdin、stdout、stderr 三个流的类型都是：FILE* ,通常称为文件指针。

在C语言中，就是通过FILE* 的文件指针来维护流的各种操作的。

2.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：

1    FILE* PF;//文件类型指针

定义pf是指向一个FILE类型的指针变量，可以使pf指向一个文件的文件信息区（是一个结构体变量），通过该文件的文件信息区就可以访问该文件。简单来说，通过文件指针可以间接性的找到与其关联的文件。

2.3 文件的打开和关闭

文件在读写之前都需要打开文件，在完成相关操作后也需要关闭文件。

在程序中打开文件时，会返回一个FILE*的指针指向该文件，相当于建立了指针和文件之间的的关系。

ANSIC规定使用fopen 和 fclose函数来进行文件的打开和关闭。

//打开⽂件
FILE * fopen ( const char * filename, const char * mode );
//关闭⽂件
int fclose ( FILE * stream );

fopen 函数返回值为指向文件的指针，第一个参数表示文件名，第二个参数表示文件的打开模式 close 函数中的参数是文件的文件指针。
文件的打开模式如下：

文件使用方式	含义	如果指定文件不存在
“r”（只读）	为了输入数据，打开一个已经存在的文本文件	出错
“w”（只写）	为了输出数据，打开一个文本文件	建立一个新的文件
“a”（追加）	向文本文件末尾添加数据	建立一个新的文件
“rb”（只读）	为了输入数据，打开一个二进制文件	出错
“wb”（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
“ab”（追加）	向一个二进制文件末尾添加数据	建立一个新的文件
“r+”（读写）	为了读和写，打开一个文本文件	出错
“w+”（读写）	为了读和写，建立一个新的文件	建立一个新的文件
“a+”（读写）	打开一个文件，在未见末尾进行读写	建立一个新的文件
“rb+”（读写）	为了读和写，打开一个二进制文件	出错
“wb+”（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
“ab+”（读写）	打开一个二进制文件，在文件末尾进行读和写	建立一个新的文件

实例代码：假设以“w”的打开模式进行打开

#include <stdio.h>
int main(){
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL){
		perror("fopen");
		return 1;
	}
	else{
		printf("文件打开成功\n");
	}
	fclose(pf);//关闭文件
	pf = NULL;//指针指向NULL 防止pf为野指针
	return 0;
}

运行上述代码，如果文件存在，并且成功打开，便会输出“文件打开成功”,倘若没有“test.txt”文件则会尝试创建该文件。
文件打开后进行相关的文件操作，操作完成后需要关闭文件，并且使pf指针指向NULL，以防pf为野指针。

那么文件的相关操作如何操作呢？这就涉及到相关函数的使用。

2.4 文件的顺序读写

2.4.1顺序读写函数介绍

以下为部分顺序读写函数介绍：
更多函数详见：<cstdio> (stdio.h) - C++ Reference

部分顺序读写函数介绍
函数名	功能	适用场景
fgetc	字符输入函数	所有输入流
fputc	字符输出函数	所有输出流
fgets	文本行输入函数	所有输入流
fputs	文本行输出函数	所有输出流
fscanf	格式化输入函数	所有输入流
fprintf	格式化输出函数	所有输出流
fread	二进制输入	文件输入流
fwrite	二进制输出	文件输出流

上面所提到的文件输入/输出流，一般指适用于标准输入/输出流和其他输入/输出流(比如文件输入/输出流) 。

2.4.1.1 fgetc 与 fputc

int fgetc ( FILE * stream );

int fputc ( int character, FILE * stream );

fgetc:

返回指定流的内部文件位置指示器当前指向的字符。然后，内部文件位置指示器前进到下一个字符。
如果调用时流位于文件末尾，则函数将返回 EOF 并设置流的文件结束指示器 （feof）。
如果发生读取错误，该函数将返回 EOF 并为流设置错误指示符 （ferror）。

简单来说，fgetc是从文件中读取一个字符然后返回该字符，如果遇到文件末尾或者读取错误会返回EOF，然后设置相应指示符。feof函数就是通过读取这里的指示符来判断是否是遇见文件尾才导致的文件结束读取。

代码实例：

int main(){
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL){
		perror("fopen");
		return 1;
	}
	else{
		printf("文件打开成功\n");
	}
int ch;
while ((ch = fgetc(pf)) != EOF)
{
	printf("%c", ch);
}
	fclose(pf);
	pf = NULL;
	return 0;
}

上述代码片段中，是用于打开一个名为 "test.txt" 的文件，并逐字符读取并打印，直到文件结束。
假设文件中的内容是字符 'a' 到 'i'（即连续的9个小写字母）。

但是，注意：在读取过程中，我们使用 fgetc 函数，它每次读取一个字符，并将文件指针位置移动到下一个字符。
当我们调用 fclose 关闭文件后，我们将文件指针 pf 设置为 NULL，这是一个好习惯，可以避免悬空指针。

读取完毕后，fgetc返回EOF 跳出循环。

fputc和fgetc恰恰相反

fputc是将指定字符输出到文件内容中。

fputc：

将字符写入流并前进位置指示器。
字符被写入流的内部位置指示器指示的位置，然后自动前进 1

成功后，将返回写入的字符。
如果发生写入错误，则返回 EOF 并设置错误指示符 （ferror）。

代码实例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(){
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL){
		perror("fopen");
		return 1;
	}
	else{
		printf("文件打开成功\n");
	}
	int i = 0;
	for ( i = 'a'; i <= 'z'; i++)
	{
		fputc(i, pf);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

运行代码后查看“test.txt”文件，发现确实已经写入

2.4.1.2 fgets 与 fputs

fgtes与 fputs 是用于处理文本行的，会读取/写入一行信息。

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

参数解释：

首先看fgets的定义，可以知道以下信息

*str 指向用于存储读取数据的字符数组的指针
num 设置最大读取数
- 最大读取数的意思就是:在一行中，最大读取num-1个字符，如果读取num-1个字符还未遇见\n，那么就会停止读取，如果在读取num-1个字符之前已经读取到了\n,那么就会提前停止
*stream 指向要读取的文件流的指针
返回值：
- 成功： 返回 str（指向缓冲区的指针）
- 失败/文件结束：
  - 如果读取前已到文件末尾 → 返回 NULL
  - 如果读取时发生错误 → 返回 NULL
注意：fgets是最多读取num-1个字符，因为本身会在末尾加上一个'\0'.

接下来看fputs的定义：

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

参数解释：

*str 指向要写入的字符串（以空字符 \0 结尾）
- 字符串内容会被写入目标流
- 字符串终止符 \0 不会被写入输出流
*stream 指定输出的目标文件流
- 可以是标准输出流 stdout（输出到控制台）
- 也可以是文件指针（通过 fopen() 打开的文件）
返回值:
- 成功：返回非负整数（通常是写入的字符数，但不一定）
- 失败：返回 EOF（通常是 -1）

不自动添加换行符

与 puts() 不同，fputs() 不会在输出后自动添加 \n。

fputs("Hello", stdout);  // 输出 "Hello" 无换行
puts("Hello");          // 输出 "Hello\n" 带换行

代码实例：

int main(){
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL){
		perror("fopen_w");
		return 1;
	}
	fputs("hello Byte\n",pf);
	fputs("hello China", pf);
	fclose(pf);
	pf = fopen("test.txt", "r");
	if (pf == NULL){
		perror("fopen_r");
		return 1;
	}
	char arr[40];
	fgets(arr, 40, pf);
	printf("%s", arr);
	fgets(arr, 40, pf);
	printf("%s", arr);
	fclose(pf);
	pf = NULL;
	return 0;
}

2.4.1.3 fscanf 与 fprintf

这是两个重要的格式化输入输出函数：fscanf 和 fprintf。它们分别用于从文件流中读取格式化输入和向文件流写入格式化输出。

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

参数解释：

FILE *stream 指向文件流的指针，指定输出的目标。
const char *format 与.....格式参照printf，这里不过多描述
返回值：
- 成功时：返回写入的字符总数（整数）。
- 失败时：返回一个负数（通常是 EOF）。

功能：将格式化的数据写入指定的文件流。类似于 printf，但 printf 默认输出到 stdout，而 fprintf 可以输出到任意文件流。

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

参数解释：

FILE *stream 指向文件流的指针，指定输入的目标。
const char *format 与.....格式参照scanf，这里不过多描述
返回值：
- 成功时：返回成功匹配并赋值的输入项的数量（整数）。
- 失败或到达文件末尾：返回 EOF（通常是 -1）或小于期望匹配项数的值（可能为0）。

功能：从指定的文件流中读取格式化输入。类似于 scanf，但 scanf 默认从 stdin 读取，而 fscanf 可以从任意文件流读取。

代码实例：

#include <stdio.h>
struct S
{
	int year;
	int month;
	int day;
}s;
int main()
{
	FILE* pf = fopen("test2.txt","r");
	if (pf == NULL)
	{
		perror("fopen_r");
		return 1;
	}
	fscanf(pf, "%d年%d月%d日", &(s.year), &(s.month), &(s.day));
	printf("%d年%d月%d日", s.year, s.month, s.day);
	fclose(pf);
	pf = fopen("test2.txt", "w");
	if (pf == NULL)
	{
		perror("fopen_w");
		return 1;
	}
	struct S k = { 2026,6,15 };
	fprintf(pf, "%d年%d月%d日", k.year, k.month, k.day);
	fclose(pf);
	pf = NULL;
	return 0;
}

2.4.1.4 fread 与 fwrite

fread 和 fwrite 是 C 语言中用于处理二进制文件的读写函数，它们比文本I/O函数（如fprintf/fscanf）高效，特别适合处理结构化数据块和大型文件。

函数原型：

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

参数解释：

const void *ptr 指向要写入数据的来源内存地址
size_t size 单个数据元素的大小（字节）
size_t count 要写入的元素个数
FILE *stream 指向目标文件流（必须以二进制读写模式打开）
返回值：
- 成功写入的元素个数（等于 count 表示完全成功）
- 若小于 count，表示部分写入或发生错误

函数原型：

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

参数解释：

void *ptr 指向目标内存位置的指针（用于存储读取数据）
size_t size 单个元素大小
size_t count 元素个数
FILE *stream 指向目标文件流（必须以二进制读写模式打开）
返回值
- 成功读取的元素个数（等于 count 表示完全成功）
- 若小于 count，可能遇到文件尾（EOF）或错误
- 返回 0 表示未读取任何数据或错误

代码实例：

#include <stdio.h>

int main() {
    // 1. 创建并写入二进制数据 ------------------------------------
    FILE* fp = fopen("data.bin", "wb"); // 二进制写模式
    if (fp == NULL)
    {
        perror("fopen_wb");
        return 1;
    }
    // 要写入的原始数据
    int write_numbers[] = { 10, 20, 30, 40, 50 };
    char write_text[] = "Hello Binary!";

    // 使用fwrite写入整数数组
    fwrite(write_numbers, sizeof(int), 5, fp);

    // 使用fwrite写入字符串
    fwrite(write_text, sizeof(char), 14, fp); // 包含结尾的\0

    fclose(fp);
    printf("数据已写入 data.bin\n");

    // 2. 读取二进制数据 ----------------------------------------
    fp = fopen("data.bin", "rb"); // 二进制读模式
    if (fp == NULL)
    {
        perror("fopen_rb");
        return 1;
    }
    // 读取整数组（5个整数）
    int read_numbers[5];
    fread(read_numbers, sizeof(int), 5, fp);

    // 读取字符串（14个字符）
    char read_text[14];
    fread(read_text, sizeof(char), 14, fp);

    fclose(fp);
    fp = NULL;
    // 3. 验证结果 --------------------------------------------
    printf("\n读取的整数: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", read_numbers[i]); // 应输出: 10 20 30 40 50
    }

    printf("\n读取的文本: %s", read_text); // 应输出: Hello Binary!

    return 0;
}

2.5 对比一组函数

1. scanf/fscanf/sscanf
2. printf/fprintf/sprintf

scanf 和 printf：用于标准输入/输出（通常是控制台）
fscanf 和 fprintf：用于文件流（任何FILE*流，包括文件、标准输入输出等）
sscanf 和 sprintf：用于字符串（内存中的字符串）

（一）、scanf 和 printf (标准输入/输出)

scanf: 从标准输入（通常是键盘）读取格式化输入。
原型：int scanf(const char *format, ...);
示例：scanf("%d %f", &i, &f);
printf: 向标准输出（通常是屏幕）输出格式化内容。
原型：int printf(const char *format, ...);
示例：printf("i=%d, f=%f\n", i, f);

（二）、fscanf 和 fprintf (文件流输入/输出)

fscanf: 从指定的文件流读取格式化输入。

原型：int fscanf(FILE *stream, const char *format, ...);
示例：fscanf(fp, "%d %f", &i, &f); // 从文件指针fp读取

fprintf: 向指定的文件流输出格式化内容。

原型：int fprintf(FILE *stream, const char *format, ...);
示例：fprintf(fp, "i=%d, f=%f\n", i, f); // 写入到文件指针fp

注意：这两个函数可以用于任何文件流，包括标准输入输出：
fscanf(stdin, ...) 等价于 scanf(...)
fprintf(stdout, ...) 等价于 printf(...)

（三）、sscanf 和 sprintf (字符串输入/输出)

sscanf: 从一个字符串中按照格式读取数据（将字符串中的内容解析为各种类型的数据）。
原型：int sscanf(const char *str, const char *format, ...);
示例：char str[] = "123 3.14"; sscanf(str, "%d %f", &i, &f); // 将字符串解析成整数和浮点数

sprintf: 将各种类型的数据按照格式写入字符串（将数据格式化成字符串）。

原型：int sprintf(char *str, const char *format, ...);
示例：char buffer[100]; sprintf(buffer, "i=%d, f=%f", i, f); // 将整数和浮点数格式化为字符串存入buffer

2.6. 文件的随机读写

2.6.1 fseek

fseek是根据文件指针的位置和偏移量来定位文件指针（可以看成文件内容的光标）

原型：

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

参数解释：

FILE *stream 指向FILE 对象的指针，该对象标识了要定位的文件流
long int offset 偏移量
- 偏移量（以字节为单位），可以是正数、负数或零。
- 正数表示向文件末尾方向移动，负数表示向文件开头方向移动。
int origin 基准位置可取下值：
- SEEK_SET(0)：从文件开头开始计算
- SEEK_CUR(1): 从当前位置开始计算
- SEEK_END(2): 从文件末尾开始计算
返回值：
- 成功返回 0
- 失败返回非零值（通常为-1）

功能：

fseek 将文件位置指针移动到距离 origin 指定的位置 offset 字节处。例如：

fseek(fp, 10, SEEK_SET);//移动到文件开头后第 10 个字节
fseek(fp, -5, SEEK_END);//移动到文件末尾前 5 个字节处

2.6.2 ftell

功能：

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

函数原型：

long int ftell ( FILE * stream );

FILE *stream 指向FILE 对象的指针，该对象标识了要定位的文件流
返回值：
- 成功返回指针相对于起始位置的偏移量
- 失败返回0

2.6.3 fewind

功能：让⽂件指针的位置回到⽂件的起始位置

函数原型：

void rewind ( FILE * stream );

FILE *stream 指向FILE 对象的指针，该对象标识了要定位的文件流

2.7 文件读取结束的判定

在文件读取结束的判定方面，有许多人都错误的使用了函数feof，许多人认为能直接使用feof的返回值来判断文件是否是因为读到文件尾才读取结束，实际上这是错误的。

在文件读取的过程中，不能使用feof的返回值来判断文件是否读取结束。

feof的作用是：当文件读取结束后，判断文件是由于遇到文件尾才结束的。

功能：

用于判断文件结束的原因

函数原型：

int feof ( FILE * stream );

FILE *stream 指向FILE 对象的指针
返回值：
- 返回非零值 → 已经到达文件末尾
- 返回 0 → 未到达文件末尾

注意：当读取到文件最后一个有效数据时，此时文件结束标志并未被设置，下一次再读取时失败，此时feof返回真。这样导致的结果是最后一次读取的数据可能会被处理两次，或者多读一次。

三、文件缓冲区

我们通常所说的文件缓冲区（File Buffer）是C标准库为了减少实际物理读写次数而设计的一种内存缓存机制。它位于应用程序和操作系统之间，用于暂存待写入文件的数据或从文件读取的数据。

那么为什么需要缓冲区？

想象一下，如果我们每次调用fputc写一个字符到磁盘文件，就需要触发一次磁盘I/O操作，那么程序的性能将极其低下。因为磁盘（特别是传统机械硬盘）的寻道时间远远超过内存操作。缓冲区机制通过批量处理数据，显著提升效率。

下面的代码可以很明显的感知到缓冲区的存在：

#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
	FILE* pf = fopen("test.txt", "w");
	fputs("abcdef", pf);//先将代码放在输出缓冲区
	printf("睡眠10s，此时打开test1.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语言在操作文件的时候，需要进行刷新缓冲区或者在文件操作结束的时候关闭文件，否则数据会在缓冲区中暂存，不会写入到文件中去。