c语言文件操作

bbppooi

已于 2024-04-18 19:07:57 修改

阅读量704

点赞数 28

文章标签： c语言数据结构

于 2024-04-14 20:43:16 首次发布

本文链接：https://blog.csdn.net/bbppooi/article/details/137753101

版权

为什么使用文件？

使用文件的主要目的是为了持久化数据，即将程序运行时产生的数据保存到计算机的存储介质中，以便在程序关闭后能够重新读取和处理。文件主要优点包括：

数据持久化：文件可以将程序运行时产生的数据永久保存到磁盘或其他存储介质中，即使程序结束运行，数据仍然保留在文件中，方便下次使用。
数据共享：文件是一种通用的数据交换格式，可以方便地在不同的程序之间共享数据。通过文件，程序可以将数据写入文件，供其他程序读取和处理。
数据备份和恢复：通过文件，程序可以定期将重要数据备份到磁盘上，以防止数据丢失或损坏。同时，如果程序发生异常终止，也可以通过文件恢复数据，减少数据损失。
数据结构化存储：文件可以以结构化的方式存储数据，例如文本文件可以按行存储数据，二进制文件可以按字节、数据结构等方式存储数据，从而方便程序读取和处理。
数据隔离和保护：文件可以根据需要进行访问控制，设置权限以限制对数据的访问。这样可以保护数据的安全性，防止未经授权的用户访问和修改数据。
数据传输和持久化存储：文件可以用于将数据从一个地方传输到另一个地方，或者将数据持久化存储到长期存储介质中，如磁盘、网络存储等。

什么是文件？

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

程序文件

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

数据文件

数据文件是计算机中存储数据的一种特殊文件，用于保存程序所需的数据。数据文件可以包含各种类型的数据，例如文本数据、图像数据、音频数据等，它们以二进制形式存储在计算机的磁盘或其他存储介质上。

数据文件通常由程序创建、读取和修改，用于在程序运行时提供数据支持。

本博客主要讲述的是数据文件的读写操作。

在没有文件操作的C语言终端程序中，数据的输入和输出都是以终端为对象的，即从终端的键盘输入数据，运行结果在屏幕上显示。但是在有文件操作的程序中，我们可以将终端的键盘输入的数据保存在磁盘中，或者将磁盘中的文件数据都取到程序内存中使用。

文件名

一个文件需要有唯一的文件标识，以便用户的识别和引用。

为了方便起见文件标识常被称为文件名。

文件名包含三个部分：文件路径+文件名主干+文件后缀

例如： c:\code\test.txt

文件指针

文件指针是一个在程序中用来访问文件的抽象概念，它实际上是一个指向文件的位置的指针。文件指针在C语言和其他一些编程语言中广泛使用，用于对文件进行读取、写入和定位等操作。

在C语言中，文件指针通常是通过标准库函数fopen()打开文件后返回的指针。它可以用来指示文件的当前位置，从而进行读取和写入操作。在对文件进行读写操作之前，需要先打开文件并将文件指针指向文件的开头或特定位置。

文件指针的主要作用包括：

文件定位：文件指针可以指示文件的当前位置，从而决定读取或写入操作发生的位置。
读取文件内容：通过文件指针可以从文件中读取数据，进行文件内容的读取和处理。
写入文件内容：文件指针也可以用来向文件中写入数据，进行文件内容的修改和更新。
文件关闭：文件指针在文件使用完成后，可以通过fclose()函数关闭文件，释放相关资源。

在使用文件指针时，需要注意对文件指针的合法性进行检查，以防止发生空指针异常或其他错误。此外，还需要注意在文件操作完成后及时关闭文件，以释放系统资源并确保数据的完整性。

vs2013中文件指针是这样定义的

struct _iobuf {
	char* ptr;
	int _cnt;
	char* _base;
	int _flag;
	int _file;
	int _charbuf;
	int _bufsiz;
	char* _tmpfname;
};
typedef struct _iobuf FILE;

文件的打开和关闭

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

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

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

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

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

mode表示文件的打开模式，下⾯都是文件的打开模式：

"r"：只读模式。文件必须存在，如果文件不存在，则打开失败。
"w"：写入模式。如果文件不存在，则创建新文件；如果文件已存在，则清空文件内容。如果打开文件失败，则返回NULL。
"a"：追加模式。如果文件不存在，则创建新文件；如果文件已存在，则在文件末尾追加内容。如果打开文件失败，则返回NULL。
"r+"：读写模式。文件必须存在，允许读取和写入文件。
"w+"：读写模式。如果文件不存在，则创建新文件；如果文件已存在，则清空文件内容，并允许读取和写入文件。
"a+"：读写追加模式。如果文件不存在，则创建新文件；如果文件已存在，则在文件末尾追加内容，并允许读取和写入文件。

注意：在Windows平台下，文本文件的换行符为"\r\n"，而在Unix/Linux平台下，文本文件的换行符为"\n"。因此在Windows平台下使用文本模式打开文件时，会自动进行换行符的转换。若要在二进制模式下操作文件，请在模式字符串后面加上"b"，例如："rb"、"wb"、"ab"、"r+b"、"w+b"、"a+b"。

文件的顺序读写

fgetc

fgetc()原型如下：

int fgetc(FILE *stream);

fgetc() 函数从指定的文件流 stream 中读取下一个字符，并将该字符作为 unsigned char 类型转换为 int 返回。如果到达文件末尾或者发生读取错误，它会返回 EOF（通常被定义为 -1）。

下面是一个示例代码，演示了如何使用 fgetc() 函数从文件中逐个字符地读取内容：

#include <stdio.h>

int main() {
    FILE *fp;
    int c;

    fp = fopen("example.txt", "r"); // 打开文件
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    while ((c = fgetc(fp)) != EOF) { // 逐个字符读取文件内容，直到文件末尾
        putchar(c); // 输出字符到标准输出
    }

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fgetc() 函数每次只读取一个字符，因此它是一个比较低级的文件读取函数。如果需要读取整行或者整个文件内容，通常会使用 fgets() 或者 fread() 等更高级的文件读取函数。

fputc

fputc()原型如下：

int fputc(int c, FILE *stream);

fputc() 函数将字符 c 写入到指定的文件流 stream 中，并返回写入的字符。如果写入成功，则返回写入的字符；如果出现错误，则返回 EOF（通常被定义为 -1）。

下面是一个示例代码，演示了如何使用 fputc() 函数向文件中逐个字符地写入内容：

#include <stdio.h>

int main() {
    FILE *fp;
    int c;

    fp = fopen("example.txt", "w"); // 打开文件（写入模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    for (c = 'A'; c <= 'Z'; c++) { // 写入字符 'A' 到 'Z'
        if (fputc(c, fp) == EOF) { // 将字符写入文件
            perror("Error writing to file");
            fclose(fp); // 关闭文件
            return 1;
        }
    }

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fputc() 函数每次只能写入一个字符，因此它是一个比较低级的文件写入函数。如果需要写入整行或者大块数据，通常会使用 fputs() 或者 fwrite() 等更高级的文件写入函数。

fgets

fgets()原型如下：

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

fgets() 函数从指定的文件流 stream 中读取一行文本，并将其存储到字符数组 str 中，最多读取 n-1 个字符（包括换行符 \n），然后在字符串末尾添加空字符 \0。如果成功读取到数据，则返回 str 指向的字符串；如果到达文件末尾或者发生读取错误，则返回 NULL。

下面是一个示例代码，演示了如何使用 fgets() 函数从文件中逐行读取内容：

#include <stdio.h>

int main() {
    FILE *fp;
    char buffer[255];

    fp = fopen("example.txt", "r"); // 打开文件（只读模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    while (fgets(buffer, sizeof(buffer), fp) != NULL) { // 逐行读取文件内容
        printf("%s", buffer); // 输出每一行内容到标准输出
    }

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fgets() 函数会保留换行符 \n，因此每行的内容包括换行符在内的总长度不会超过 n-1。如果不希望保留换行符，可以使用 fgets() 函数读取每行内容后，手动将换行符替换为空字符。

fputs

fputs()原型如下：

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

fputs() 函数将字符串 str 写入到指定的文件流 stream 中，直到遇到字符串结束符 \0。如果写入成功，则返回一个非负数；如果出现错误，则返回 EOF（通常被定义为 -1）。

下面是一个示例代码，演示了如何使用 fputs() 函数向文件中写入字符串：

#include <stdio.h>

int main() {
    FILE *fp;

    fp = fopen("example.txt", "w"); // 打开文件（写入模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    if (fputs("Hello, world!\n", fp) == EOF) { // 向文件中写入字符串
        perror("Error writing to file");
        fclose(fp); // 关闭文件
        return 1;
    }

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fputs() 函数只能写入字符串，不能写入单个字符。如果需要写入单个字符，可以使用 fputc() 函数。

fscanf

fscanf() 是C语言标准库中用于从文件中按照指定格式读取数据的函数。它的原型如下：

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

fscanf() 函数从指定的文件流 stream 中读取数据，并根据格式字符串 format 进行解析和存储。它类似于 scanf() 函数，但是 fscanf() 从文件中读取数据，而 scanf() 则从标准输入（键盘）中读取数据。

下面是一个示例代码，演示了如何使用 fscanf() 函数从文件中按照指定格式读取数据：

#include <stdio.h>

int main() {
    FILE *fp;
    int num1, num2;

    fp = fopen("input.txt", "r"); // 打开文件（只读模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 从文件中读取两个整数，并将它们存储到变量 num1 和 num2 中
    if (fscanf(fp, "%d %d", &num1, &num2) != 2) { // 读取两个整数
        perror("Error reading from file");
        fclose(fp); // 关闭文件
        return 1;
    }

    printf("Read numbers: %d and %d\n", num1, num2);

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fscanf() 函数根据格式字符串 format 来解析文件中的内容，所以要确保格式字符串与文件内容匹配，否则可能会导致读取错误或者结果不符合预期。

fprintf

fprintf()原型如下：

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

fprintf() 函数将按照格式字符串 format 中的指定格式，将数据写入到指定的文件流 stream 中。它类似于 printf() 函数，但是 fprintf() 将输出数据到文件中，而 printf() 输出数据到标准输出（屏幕）中。

下面是一个示例代码，演示了如何使用 fprintf() 函数向文件中按照指定格式写入数据：

#include <stdio.h>

int main() {
    FILE *fp;

    fp = fopen("output.txt", "w"); // 打开文件（写入模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 向文件中按照指定格式写入数据
    fprintf(fp, "Hello, world!\n");
    fprintf(fp, "The answer is %d\n", 42);

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fprintf() 函数的用法与 printf() 函数类似，但是要指定输出的文件流，确保将数据写入到正确的文件中。

fread

fread()原型如下：

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

fread() 函数从指定的文件流 stream 中读取数据，并将读取的数据存储到由 ptr 指向的内存块中。参数 size 指定了每个数据块的大小（以字节为单位），参数 nmemb 指定了要读取的数据块的数量。函数返回成功读取的数据块数量，如果发生错误或到达文件末尾，则返回的数量可能小于 nmemb。

下面是一个示例代码，演示了如何使用 fread() 函数从文件中读取数据块：

#include <stdio.h>

int main() {
    FILE *fp;
    char buffer[100];

    fp = fopen("data.bin", "rb"); // 打开二进制文件（只读模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 从文件中读取数据块到缓冲区
    size_t bytes_read = fread(buffer, sizeof(char), sizeof(buffer), fp);
    if (bytes_read == 0) {
        perror("Error reading from file");
        fclose(fp); // 关闭文件
        return 1;
    }

    printf("Read %zu bytes from file\n", bytes_read);

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fread() 函数用于二进制文件的读取，它会从文件中按照指定的大小和数量读取数据块，而不会对数据进行格式化。

fwrite

fwrite()原型如下：

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

fwrite() 函数将由 ptr 指向的内存块中的数据写入到指定的文件流 stream 中。参数 size 指定了每个数据块的大小（以字节为单位），参数 nmemb 指定了要写入的数据块的数量。函数返回成功写入的数据块数量，如果发生错误，则返回的数量可能小于 nmemb。

下面是一个示例代码，演示了如何使用 fwrite() 函数向文件中写入数据块：

#include <stdio.h>

int main() {
    FILE *fp;
    char buffer[] = "Hello, world!";

    fp = fopen("output.txt", "w"); // 打开文件（写入模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 向文件中写入数据块
    size_t bytes_written = fwrite(buffer, sizeof(char), sizeof(buffer), fp);
    if (bytes_written != sizeof(buffer)) {
        perror("Error writing to file");
        fclose(fp); // 关闭文件
        return 1;
    }

    printf("Wrote %zu bytes to file\n", bytes_written);

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fwrite() 函数用于二进制文件的写入，它将指定大小和数量的数据块写入文件中，而不会对数据进行格式化。

文件的随机读写

fseek

fseek()原型如下：

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

fseek() 函数将文件流 stream 的位置指针设置为指定的位置。参数 offset 指定了偏移量，可以是正数、负数或零，表示相对于 whence 参数所指定位置的偏移量。参数 whence 可以取以下值之一：

SEEK_SET：将位置指针设置为距离文件起始处 offset 字节的位置。
SEEK_CUR：将位置指针设置为距离当前位置 offset 字节的位置。
SEEK_END：将位置指针设置为距离文件末尾 offset 字节的位置。

函数返回值为0表示成功，非零值表示失败。

下面是一个示例代码，演示了如何使用 fseek() 函数设置文件位置指针的位置：

#include <stdio.h>

int main() {
    FILE *fp;
    char ch;

    fp = fopen("input.txt", "r"); // 打开文件（读取模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 设置文件位置指针到文件末尾前5个字节处
    if (fseek(fp, -5L, SEEK_END) != 0) {
        perror("Error seeking file");
        fclose(fp); // 关闭文件
        return 1;
    }

    // 读取文件中的字符
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，fseek() 函数可以用于在文件中定位到指定的位置，然后进行读取或写入操作。

ftell

ftell()原型如下：

long ftell(FILE *stream);

ftell() 函数返回指定文件流 stream 当前位置指针相对于文件起始位置的偏移量（以字节为单位）。如果调用成功，返回值为当前位置指针的偏移量；如果调用失败，则返回值为-1L。

下面是一个示例代码，演示了如何使用 ftell() 函数获取文件位置指针的当前位置:

#include <stdio.h>

int main() {
    FILE *fp;
    long position;

    fp = fopen("input.txt", "r"); // 打开文件（读取模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 获取文件位置指针当前位置
    position = ftell(fp);
    if (position == -1L) {
        perror("Error getting file position");
        fclose(fp); // 关闭文件
        return 1;
    }

    printf("Current file position: %ld\n", position);

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，ftell() 函数返回的文件位置指针的偏移量是相对于文件起始位置的，单位是字节。

rewind

rewind()原型如下：

void rewind(FILE *stream);

rewind() 函数将指定文件流 stream 的位置指针设置为文件的起始位置。调用该函数后，文件位置指针将指向文件的开头，以便后续读取或写入操作重新开始。

下面是一个示例代码，演示了如何使用 rewind() 函数将文件位置指针重新定位到文件起始位置：

#include <stdio.h>

int main() {
    FILE *fp;
    char ch;

    fp = fopen("input.txt", "r"); // 打开文件（读取模式）
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 将文件位置指针重新定位到文件起始位置
    rewind(fp);

    // 读取文件中的字符并输出到标准输出
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }

    fclose(fp); // 关闭文件

    return 0;
}

需要注意的是，rewind() 函数是用于重新定位文件位置指针到文件起始位置的快捷方式，相当于 fseek(stream, 0L, SEEK_SET)。

文件读取结束的判定

牢记：在文件读取过程中，不能⽤feof函数的返回值直接来判断文件的是否结束。

feof 的作⽤是：当文件读取结束的时候，判断是读取结束的原因是否是：遇到文件尾结束。

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

例如：

fgetc 判断是否为 EOF .

fgets 判断返回值是否为 NULL .

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

例如：

fread判断返回值是否小于实际要读的个数。

文本文件的例子

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
 int c; // 注意：int，⾮char，要求处理EOF
 FILE* fp = fopen("test.txt", "r");
 if(!fp) {
 perror("File opening failed");
 return EXIT_FAILURE;
 }
 //fgetc 当读取失败的时候或者遇到⽂件结束的时候，都会返回EOF
 while ((c = fgetc(fp)) != EOF) // 标准C I/O读取⽂件循环
 { 
 putchar(c);
 }
 //判断是什么原因结束的
 if (ferror(fp))
 puts("I/O error when reading");
 else if (feof(fp))
 puts("End of file reached successfully");
 fclose(fp);
}

二进制文件的例子

#include <stdio.h>

enum { SIZE = 5 };

int main(void)
{
    double a[SIZE] = {1., 2., 3., 4., 5.};
    FILE *fp = fopen("test.bin", "wb"); // 必须使用二进制模式

    // 写入 double 的数组
    fwrite(a, sizeof *a, SIZE, fp);

    fclose(fp);

    double b[SIZE];
    fp = fopen("test.bin", "rb");

    // 读取 double 的数组
    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;
}

文件缓冲区

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

#include <stdio.h>
#include <windows.h>
//VS2019 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语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。
如果不做，可能导致读写文件的问题。