C语言【进阶篇】之文件操作——开启代码世界里文件的神秘旅程

最新推荐文章于 2025-04-16 11:08:04 发布

EnigmaCoder

最新推荐文章于 2025-04-16 11:08:04 发布

阅读量1.2k

点赞数 41

分类专栏： C语言文章标签： c语言开发语言

本文链接：https://blog.csdn.net/2402_88461821/article/details/146542245

版权

C语言专栏收录该内容

12 篇文章

订阅专栏

🚀前言

大家好！我是 EnigmaCoder。本文收录于我的专栏 C，感谢您的支持！

在计算机编程的广阔领域中，数据的持久化存储与交互是一项至关重要的任务。C语言作为一门经典且高效的编程语言，为开发者提供了强大而灵活的文件操作功能。通过文件操作，我们能够将程序运行过程中产生的数据保存到外部存储设备中，以便后续的查看、分析和使用；同时，也可以从外部文件中读取数据，为程序的运行提供必要的输入。无论是开发小型的控制台程序，还是构建大型的系统软件，文件操作都扮演着不可或缺的角色。本文将深入探讨C语言文件操作的各个方面，从文件的基本概念入手，逐步介绍文件的打开、关闭、读写以及随机访问等操作，通过丰富的示例代码帮助你全面掌握这一重要技能。

✍️文件基础概念

💯文件类型

在程序设计的范畴内，文件主要分为程序文件和数据文件。程序文件是与程序的编译、链接和执行过程密切相关的文件。源程序文件（通常以 .c 为后缀）是我们编写C语言代码的文本文件，其中包含了程序的逻辑和算法。经过编译器的处理，源程序文件会被转换为目标文件（在Windows环境下，目标文件的后缀通常为 .obj），目标文件是二进制文件，包含了机器码，但还不能直接运行。最后，通过链接器将多个目标文件以及必要的库文件进行链接，生成可执行程序（在Windows环境下，可执行程序的后缀为 .exe）。

而数据文件则专注于数据的存储和管理。它们用于保存程序运行过程中产生的数据，或者为程序提供外部输入数据。数据文件可以是文本文件，其中的数据以人类可读的文本形式存储；也可以是二进制文件，数据以二进制形式存储，更适合存储复杂的数据结构和大规模的数据。

💯文本文件与二进制文件

根据数据的存储形式，数据文件可以进一步分为文本文件和二进制文件。数据在计算机内存中是以二进制形式存在的，当我们将这些数据输出到外存文件时，有两种不同的存储方式。

如果将数据转换为ASCII码形式存储在外存，这样的文件就是文本文件。例如，对于整数 10000，在文本文件中它会被表示为字符 '1'、'0'、'0'、'0'、'0'，每个字符占用1个字节，因此总共需要5个字节的存储空间。文本文件的优点是可读性强，我们可以直接使用文本编辑器打开并查看其中的内容；缺点是存储效率相对较低，尤其是对于一些复杂的数据结构。

若直接将内存中的数据以二进制形式输出到外存文件，该文件就是二进制文件。对于整数 10000，在32位系统中，它通常只占4个字节的存储空间。二进制文件的优点是存储效率高，读写速度快，适合存储大规模的数据和复杂的数据结构；缺点是可读性差，不能直接使用文本编辑器查看，需要通过特定的程序进行解析。

下面的代码可以验证整数以二进制形式存储的情况：

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

在这个代码中，我们使用 fopen 函数以二进制写入模式（"wb"）打开文件 test.txt，然后使用 fwrite 函数将整数 a 的二进制数据写入文件，最后关闭文件。

💯文件名

文件名是文件的唯一标识，它由文件路径、文件名主干和文件后缀三部分组成。文件路径指定了文件在文件系统中的位置，它可以是绝对路径，也可以是相对路径。绝对路径从文件系统的根目录开始，完整地描述了文件的存储位置；相对路径则是相对于当前工作目录的路径。

文件名主干是文件的主要名称，用于区分不同的文件。文件后缀通常用于表示文件的类型，例如 .txt 表示文本文件，.jpg 表示图像文件，.exe 表示可执行文件等。操作系统和应用程序可以根据文件后缀来识别文件的类型，并采取相应的处理方式。

例如，文件名 c:\code\test.txt 中，c:\code\ 是文件路径，test 是文件名主干，.txt 是文件后缀。明确的文件名结构有助于操作系统准确地定位和管理文件，也方便我们在程序中对文件进行操作。

🐍文件指针与流

💯文件指针

在C语言的缓冲文件系统中，文件指针是一个核心概念。当我们打开一个文件时，系统会自动在内存中为该文件创建一个文件信息区，这个区域实际上是一个结构体变量，用于存放文件的相关信息，如文件的名字、当前状态、文件当前的位置等。这个结构体类型由系统声明，命名为 FILE。

不同的C编译器中，FILE 结构体的具体内容可能会有一些差异，但基本功能是相似的。例如在Visual Studio 2022中，stdio.h 头文件里就包含了 FILE 结构体的详细定义。

我们通过定义 FILE* 类型的文件指针变量来操作文件。例如：

FILE* pf;

这里的 pf 就是一个指向 FILE 类型数据的指针变量，它可以指向某个文件的文件信息区。通过这个指针，我们就能访问与它关联的文件，实现对文件的各种操作，如读取、写入、定位等。

💯流

为了简化对各种外部设备（如键盘、显示器、磁盘等）的数据输入输出操作，C语言引入了“流”的概念。可以将流看作是一个数据的通道，数据从数据源（如文件、键盘）通过流传输到程序中，或者从程序通过流输出到目的地（如文件、显示器）。

C程序对文件、屏幕、键盘等的数据输入输出操作都是通过流来实现的。在程序启动时，系统会默认打开三个标准流：

标准输入流（stdin）：通常对应键盘输入，程序可以通过标准输入流从键盘读取用户输入的数据。例如，scanf 函数就是从标准输入流中读取数据的。
标准输出流（stdout）：一般用于将数据输出到显示器屏幕，程序可以通过标准输出流将计算结果、提示信息等显示给用户。例如，printf 函数就是向标准输出流输出信息的。
标准错误流（stderr）：同样输出到显示器屏幕，主要用于输出错误信息。当程序在运行过程中发生错误时，可以通过标准错误流将错误信息及时反馈给用户，方便调试和排查问题。

这三个标准流的类型都是 FILE*，这是因为操作系统将各种设备都统一当作“文件”来处理，所以通过 FILE* 类型的文件指针来维护流的操作，使得我们在编程时无需过多关注设备的差异，能够以统一的方式进行数据的输入输出。

🤔文件的打开与关闭

💯fopen函数

文件在进行读写等操作之前，必须先打开。ANSI C标准规定使用 fopen 函数来打开文件，其函数原型为：

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

其中，filename 是要打开的文件名，需要包含文件路径（如果文件在当前目录下，可以只写文件名）；mode 是文件打开模式，用于指定对文件的操作方式。

常见的文件打开模式有：

“r”（只读模式）：用于打开一个已经存在的文本文件，只能从文件中读取数据，不能写入。如果文件不存在，fopen 函数会返回 NULL，表示打开失败。例如：

FILE* fp = fopen("example.txt", "r");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“w”（只写模式）：打开一个文本文件并清空文件内容，如果文件不存在则创建一个新文件。这种模式下，只能向文件写入数据，不能读取。例如：

FILE* fp = fopen("test.txt", "w");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“a”（追加模式）：打开一个文本文件，将写入的数据追加到文件末尾。若文件不存在，也会创建新文件。例如：

FILE* fp = fopen("log.txt", "a");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“rb”（二进制只读模式）：用于打开一个已经存在的二进制文件，以二进制形式读取数据。例如：

FILE* fp = fopen("data.bin", "rb");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“wb”（二进制只写模式）：打开一个二进制文件并清空内容，若文件不存在则新建，以二进制形式写入数据。例如：

FILE* fp = fopen("image.bin", "wb");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“r+”（读写模式）：打开一个已存在的文本文件，既可以读取数据，也可以写入数据。例如：

FILE* fp = fopen("config.txt", "r+");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“w+”（读写模式）：先创建一个新文件，然后可以进行读写操作。如果文件已存在，会清空文件内容。例如：

FILE* fp = fopen("temp.txt", "w+");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

“a+”（读写模式）：打开文件并将文件指针移动到文件末尾，既可以追加数据，也可以读取文件内容。若文件不存在，会创建新文件。例如：

FILE* fp = fopen("history.txt", "a+");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

💯fclose函数

文件使用完毕后，应该及时关闭，以释放系统资源，避免数据丢失或出现其他错误。ANSI C规定使用 fclose 函数来关闭文件，其函数原型为：

int fclose ( FILE * stream );

stream 是要关闭的文件指针。如果文件成功关闭，fclose 函数返回 0；如果关闭过程中出现错误，返回 EOF（通常定义为 -1）。

例如：

fclose(fp);
fp = NULL;

关闭文件后，将文件指针赋值为 NULL，这是一个良好的编程习惯，可以避免悬空指针的问题。悬空指针是指指针指向的内存已经被释放，但指针仍然保留着原来的地址，继续使用悬空指针可能会导致程序崩溃或产生不可预期的结果。

🖊️文件的顺序读写

💯字符读写函数：fgetc和fputc

fgetc函数
fgetc 函数用于从文件中读取一个字符，其函数原型为：

int fgetc ( FILE * stream );

stream 是文件指针，函数返回读取到的字符，如果读取到文件末尾或发生错误，返回 EOF（End Of File，通常定义为 -1）。

例如，下面的代码从 test.txt 文件中逐个读取字符，并将其输出到屏幕上，直到读取到文件末尾：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "r");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    int ch;
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 while 循环不断调用 fgetc 函数读取字符，直到返回 EOF 为止。每次读取到的字符通过 putchar 函数输出到屏幕上。

fputc函数
fputc 函数用于将一个字符写入文件，其函数原型为：

int fputc ( int character, FILE * stream );

character 是要写入的字符，stream 是文件指针。如果写入成功，返回写入的字符；如果发生错误，返回 EOF。

例如，下面的代码将字符 'A' 写入 test.txt 文件中：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "w");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    char ch = 'A';
    fputc(ch, fp);
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 fputc 函数将字符 ch 写入文件，然后关闭文件。

💯字符串读写函数：fgets和fputs

fgets函数
fgets 函数用于从文件中读取一行字符串，其函数原型为：

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

str 是用于存储读取到的字符串的字符数组，num 是要读取的最大字符数（包括最后的 '\0'），stream 是文件指针。函数返回 str，如果读取到文件末尾或发生错误，返回 NULL。

例如，下面的代码从 test.txt 文件中逐行读取字符串，并输出到屏幕上：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "r");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    char line[100];
    while (fgets(line, sizeof(line), fp) != NULL) {
        printf("%s", line);
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 while 循环不断调用 fgets 函数读取一行字符串，直到返回 NULL 为止。每次读取到的字符串通过 printf 函数输出到屏幕上。

fputs函数
fputs 函数用于将一个字符串写入文件，其函数原型为：

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

str 是要写入的字符串，stream 是文件指针。如果写入成功，返回一个非负整数；如果发生错误，返回 EOF。

例如，下面的代码将字符串 "Hello, World!" 写入 test.txt 文件中：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "w");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    const char* str = "Hello, World!";
    fputs(str, fp);
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 fputs 函数将字符串 str 写入文件，然后关闭文件。

💯格式化读写函数：fscanf和fprintf

fscanf函数
fscanf 函数用于从文件中按照指定格式读取数据，其函数原型为：

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

stream 是文件指针，format 是格式化字符串，后面的省略号表示可变参数列表，根据 format 的格式来接收读取到的数据。

例如，假设 test.txt 文件中存储了一些整数，每行一个，下面的代码可以从文件中读取整数并输出到屏幕上：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "r");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    int num;
    while (fscanf(fp, "%d", &num) != EOF) {
        printf("%d ", num);
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 while 循环不断调用 fscanf 函数读取整数，直到返回 EOF 为止。每次读取到的整数通过 printf 函数输出到屏幕上。

fprintf函数
fprintf 函数用于将格式化的数据写入文件，其函数原型为：

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

stream 是文件指针，format 是格式化字符串，后面的省略号表示可变参数列表，根据 format 的格式将数据写入文件。

例如，下面的代码将格式化的数据 "Number: 123" 和 "String: Hello" 写入 test.txt 文件中：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "w");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    int num = 123;
    const char* str = "Hello";
    fprintf(fp, "Number: %d\nString: %s", num, str);
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 fprintf 函数将整数 num 和字符串 str 按照指定的格式写入文件，然后关闭文件。

💯二进制读写函数：fread和fwrite

fread函数
fread 函数用于从二进制文件中读取数据块，其函数原型为：

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

ptr 是指向存储读取数据的内存地址，size 是每个数据项的字节大小，count 是要读取的数据项数量，stream 是文件指针。函数返回实际读取到的数据项数量，如果读取过程中发生错误或到达文件末尾，返回值可能小于 count。

例如，下面的代码从 data.bin 二进制文件中读取5个整数到数组 data 中，并输出到屏幕上，同时检查读取是否成功以及是否到达文件末尾或发生错误：

#include <stdio.h>
int main() {
    FILE* fp = fopen("data.bin", "rb");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    int data[5];
    size_t ret = fread(data, sizeof(int), 5, fp);
    if (ret == 5) {
        for (int i = 0; i < 5; i++) {
            printf("%d ", data[i]);
        }
    } else {
        if (feof(fp)) {
            printf("Unexpected end of file\n");
        } else if (ferror(fp)) {
            perror("Error reading file");
        }
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 fread 函数从文件中读取5个整数到数组 data 中，然后根据返回值判断读取是否成功。如果返回值等于 5，说明读取成功，将数组中的元素输出到屏幕上；否则，检查是否到达文件末尾或发生错误，并输出相应的信息。

fwrite函数
fwrite 函数用于将数据块写入二进制文件，其函数原型为：

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

ptr 是指向要写入数据的内存地址，size 是每个数据项的字节大小，count 是要写入的数据项数量，stream 是文件指针。函数返回实际写入的数据项数量，如果写入过程中发生错误，返回值可能小于 count。

例如，下面的代码将数组 data 中的5个整数以二进制形式写入 data.bin 文件中：

#include <stdio.h>
int main() {
    FILE* fp = fopen("data.bin", "wb");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    int data[5] = {1, 2, 3, 4, 5};
    fwrite(data, sizeof(int), 5, fp);
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 fwrite 函数将数组 data 中的5个整数以二进制形式写入文件，然后关闭文件。

⚙️文件的随机读写

💯fseek函数

fseek 函数用于根据文件指针的位置和偏移量来定位文件指针，从而实现文件的随机读写，其函数原型为：

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

stream 是文件指针，offset 是偏移量，origin 指定起始位置。origin 可以取值为 SEEK_SET（文件开头）、SEEK_CUR（当前位置）、SEEK_END（文件末尾）。

例如，要将文件指针移动到文件开头往后偏移10个字节的位置，可以这样写：

fseek(fp, 10, SEEK_SET);

如果要在文件中插入内容，可以先将文件指针移动到插入位置，然后进行写入操作。比如在文件 example.txt 的第9个字符位置插入 " sam"：

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

在这个代码中，我们先以二进制写入模式打开文件 example.txt，并写入字符串 "This is an apple."，然后使用 fseek 函数将文件指针移动到第9个字符位置，最后写入字符串 " sam"。

💯ftell函数

ftell 函数用于返回文件指针相对于起始位置的偏移量，其函数原型为：

long int ftell ( FILE * stream );

stream 是文件指针。通过 ftell 函数，我们可以获取文件指针的当前位置，这在文件操作中非常有用，比如可以用于计算文件的大小。

例如，下面的代码可以计算文件 myfile.txt 的大小：

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

在这个代码中，我们先以二进制只读模式打开文件 myfile.txt，然后使用 fseek 函数将文件指针移动到文件末尾，接着使用 ftell 函数获取文件指针的位置，即文件的大小，最后关闭文件并输出文件大小。

💯rewind函数

rewind 函数用于将文件指针重新定位到文件的起始位置，其函数原型为：

void rewind ( FILE * stream );

stream 是文件指针。在文件读写过程中，如果需要重新从文件开头读取数据，可以使用 rewind 函数。

例如，下面的代码先向文件 test.txt 中写入一些数据，然后将文件指针重新定位到文件开头，再从文件中读取数据并输出到屏幕上：

#include <stdio.h>
int main() {
    FILE* fp = fopen("test.txt", "w+");
    if (fp == NULL) {
        perror("Failed to open file");
        return 1;
    }
    fputs("Hello, World!", fp);
    rewind(fp);
    char ch;
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们先以读写模式打开文件 test.txt，并写入字符串 "Hello, World!"，然后使用 rewind 函数将文件指针重新定位到文件开头，最后使用 fgetc 函数从文件中读取字符并输出到屏幕上。

💻文件读取结束的判定

在文件读取过程中，不能直接用 feof 函数判断文件是否结束。feof 函数用于判断文件读取结束的原因是否是遇到文件尾。对于不同类型的文件和读写函数，判断文件读取结束的方法也有所不同。

💯文本文件

对于文本文件，使用 fgetc 函数时，可以通过判断返回值是否为 EOF 来确定是否读取到文件末尾；使用 fgets 函数时，可以通过判断返回值是否为 NULL 来确定是否读取结束。

例如，下面的代码使用 fgetc 函数读取文本文件，并判断是否读取到文件末尾：

#include <stdio.h>
#include <stdlib.h>
int main(void) {
    int c;
    FILE* fp = fopen("test.txt", "r");
    if (!fp) {
        perror("File opening failed");
        return EXIT_FAILURE;
    }
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    if (ferror(fp)) {
        puts("I/O error when reading");
    } else if (feof(fp)) {
        puts("End of file reached successfully");
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们使用 while 循环不断调用 fgetc 函数读取字符，直到返回 EOF 为止。读取结束后，使用 ferror 函数检查是否发生I/O错误，使用 feof 函数检查是否到达文件末尾，并输出相应的信息。

💯二进制文件

对于二进制文件，使用 fread 函数时，可以通过判断返回值是否小于实际要读的个数来判断是否读取结束。

例如，下面的代码使用 fread 函数读取二进制文件，并判断是否读取结束：

#include <stdio.h>
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);
    fclose(fp);

    double b[SIZE];
    fp = fopen("test.bin", "rb");
    size_t ret_code = fread(b, sizeof *b, SIZE, fp);
    if (ret_code == SIZE) {
        puts("Array read successfully, contents: ");
        for (int n = 0; n < SIZE; ++n) {
            printf("%f ", b[n]);
        }
        putchar('\n');
    } else {
        if (feof(fp)) {
            printf("Error reading test.bin: unexpected end of file\n");
        } else if (ferror(fp)) {
            perror("Error reading test.bin");
        }
    }
    fclose(fp);
    return 0;
}

在这个代码中，我们先将数组 a 中的数据以二进制形式写入文件 test.bin，然后再从文件中读取数据到数组 b 中。使用 fread 函数读取数据时，根据返回值 ret_code 判断是否读取成功。如果 ret_code 等于 SIZE，说明读取成功，输出数组中的元素；否则，使用 feof 函数检查是否到达文件末尾，使用 ferror 函数检查是否发生错误，并输出相应的信息。

🐧文件缓冲区

ANSIC标准采用“缓冲文件系统”处理数据文件，系统会为每个正在使用的文件在内存开辟文件缓冲区。从内存向磁盘输出数据时，先存入缓冲区，缓冲区满后再写入磁盘；从磁盘读数据则先读入缓冲区，再逐个送到程序数据区。缓冲区大小由C编译系统决定。

例如，以下代码展示了缓冲区的作用：

#include <stdio.h>
#include <windows.h>
int main() {
    FILE* pf = fopen("test.txt", "w");
    if (pf == NULL) {
        perror("Failed to open file");
        return 1;
    }
    fputs("abcdef", pf);
    printf("睡眠10秒-已经写数据了,打开test.txt文件,发现文件没有内容\n");
    Sleep(10000);
    printf("刷新缓冲区\n");
    fflush(pf);
    printf("再睡眠10秒-此时,再次打开test.txt文件,文件有内容了\n");
    Sleep(10000);
    fclose(pf);
    return 0;
}

在这个代码中，我们先以写入模式打开文件 test.txt，然后使用 fputs 函数向文件中写入字符串 "abcdef"。由于缓冲区的存在，此时数据并没有立即写入磁盘。接着程序进入睡眠状态10秒，在这期间打开文件会发现文件没有内容。然后使用 fflush 函数刷新缓冲区，将缓冲区中的数据强制写入磁盘。再次进入睡眠状态10秒，此时打开文件会发现文件中有内容了。

由此可见，操作文件时需注意刷新缓冲区或关闭文件，否则可能出现读写问题。关闭文件时，系统会自动刷新缓冲区，将缓冲区中的数据写入磁盘。因此，在文件操作结束后，及时关闭文件是一个良好的编程习惯。

🌟总结

C语言文件操作是一个丰富而复杂的领域，涵盖了文件的定义、打开关闭、读写操作、随机访问以及缓冲区管理等多个方面。熟练掌握这些知识，能让我们更好地处理数据的持久化存储和交互。
在实际编程中，要根据具体需求选择合适的文件操作方式。例如，对于简单的文本数据读写，可以使用字符读写函数和字符串读写函数；对于格式化的数据，可以使用格式化读写函数；对于大规模的数据和复杂的数据结构，二进制读写函数则更为合适。同时，要注意文件打开模式的选择，避免因模式选择不当而导致数据丢失或错误。
在文件读取过程中，要正确判断文件是否读取结束，避免错误地使用 feof 函数。对于文件的随机读写，要灵活运用 fseek、ftell 和 rewind 函数，实现对文件的精确操作。
此外，文件缓冲区的存在对文件操作有重要影响，要注意及时刷新缓冲区或关闭文件，确保数据的完整性和一致性。通过不断实践，我们能更深入理解文件操作的原理，编写出高效、稳定的程序，让数据在程序与外部存储之间顺畅流通，发挥更大的价值。