【C语言】文件操作，文件读写详细介绍

我们前面学习结构体时，写通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件或存放到数据库等方式。
使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

文件概念

1. 什么是文件？

1. 文件是指磁盘上的文件。

2. 在以前学习中所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处的就是磁盘上文件。

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

2. 程序文件

1. 源文件(后缀为.c)。

2. 目标文件(windows环境下后缀为.obj)。

3. 可执行程序(windows环境下后缀为.exe)。

3. 数据文件

程序运行需要从中读取数据的文件，或者输出内容的文件。

4. 文件名

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

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

3. 文件名包含3部分：文件路径+文件名主干+文件后缀，例如： c:\code\ + test + .txt

文件的使用

1. 文件指针

1. 文件指针是指文件类型的指针。

2. 每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息(如文件的名字，文件状态及文件当前的位置等)。

3. 这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名FILE。
struct _iobuf {
    char *_ptr;
    int _cnt;
    char *_base;
    int _flag;
    int _file; 
    int _charbuf; 
    int _bufsiz;
    char *_tmpfname;
        };

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

5. 每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。
FILE* pf; //文件指针变量
6. 定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区(是一个结构体变量)。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

2. 文件的打开与关闭

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

打开文件
FILE* fopen(const char* filename, const char* mode);
关闭文件
int fclose(FILE* stream);
2. 打开模式(mode)如下：

.

3. 例子
int main ()
{
    FILE* pFile;
    //打开文件
    pFile = fopen("myfile.txt","w");
    //文件操作
    if (pFile!=NULL)
    {
        fputs("fopen example",pFile);
        //关闭文件
        fclose(pFile);
    }
    return 0;
}

文件的顺序读写

1. 顺序读写函数

1. 将一个字符写入流中。

int fputc(int character, FILE* stream);

//例子
int main ()
{
    FILE* pFile = fopen("myfile.txt","w");
    fputc('a', pFile);  
    fclose(pFile);
    
    return 0;
}

2. 从流中获取一个字符。

int fgetc(FILE* stream);

//例子
int main ()
{
    FILE* pFile = fopen("myfile.txt","r");
    int ch = fgetc(pFile);  
    printf("%c\n", ch);
    fclose(pFile);
    
    return 0;
}

读的原理：文件打开，文件指针默认指向起始位置，读一个之后文件指针就往后一个位置。

3. 读与写的理解

这里我们的主语(主视角)始终是程序。

4. 将字符串写入流

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

//例子
int main()
{
    FILE* pFile = fopen("myfile.txt", "w");
    fputs("abc\n", pFile);
    fclose(pFile);
    pFile = NULL;

    return 0;
}

5. 从流中获取字符串

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

读num-1个，或者遇到换行，或者到文件末尾停下。

int main()
{
    FILE* pFile = fopen("myfile.txt", "r");
    char str[10];
    fgets(str, 10, pFile);
    printf("%s\n", str);
    fclose(pFile);
    pFile = NULL;

    return 0;
}

6. 将格式化数据写入流

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

例子

struct S
{
    int i;
    float f;
}s = {1, 3.1f};

int main()
{
    FILE* pFile = fopen("myfile.txt", "w");
    
    fprintf(pFile, "%d, %f", s.i, s.f);

    fclose(pFile);
    pFile = NULL;

    return 0;
}

7. 从流中读取格式化数据

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

例子

struct S
{
    int i;
    float f;
}s = { 0 };

int main()
{
    FILE* pFile = fopen("myfile.txt", "r");

    fscanf(pFile, "%d, %f", &(s.i), &(s.f));
    printf("%d, %f", s.i, s.f);

    fclose(pFile);
    pFile = NULL;

    return 0;
}

8. 将数据块写入流(二进制输出)

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

从 ptr 指向的空间开始拷贝 count 个大小为 size 的数据到 stream 流中。

struct S
{
    int i;
    float f;
};

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

    struct S s = { 1, 1.0 };
    fwrite(&s, sizeof(s), 1, pf);

    fclose(pf);
    pf = NULL;

    return 0;
}

因为是二进制文件，所以用文本文件打开就会乱码。

9. 从流中读取数据块(二进制输入)

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

从 stream 流中读 count 个大小为 size 的数据放到 ptr 所指向的空间。

struct S
{
    int i;
    float f;
};

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

    struct S s;
    fread(&s, sizeof(s), 1, pf);
    printf("%d, %f\n", s.i, s.f);

    fclose(pf);
    pf = NULL;

    return 0;
}

2. scanf系列与printf系列

printf系列

1. 将格式化数据打印到 stdout
int printf(const char* format, ...);
2. 将格式化数据写入流
int fprintf(FILE* stream, const char* format, ...);
3. 将格式化数据写入字符串
int sprintf(char* str, const char* format, ...);
scanf系列

1. 从 stdin 读取格式化数据
int scanf(const char* format, ...);
2. 从流中读取格式化数据
int fscanf(FILE* stream, const char* format, ...);
3. 从字符串中读取格式化数据
int sscanf(const char* s, const char* format, ...);
sprintf与sscanf的例子
struct S
{
    int i;
    float f;
};

int main()
{
    char arr[20];
    struct S s = { 1, 1.0 };
    sprintf(arr, "%d, %f", s.i, s.f);
    printf("arr:%s\n", arr);
    struct S tmp;
    sscanf(arr, "%d, %f", &(tmp.i), &(tmp.f));
    printf("tmp:%d, %f\n", tmp.i, tmp.f);

    return 0;
}

文件的随机读写

1. fseek

int fseek(FILE* stream, long int offset, int origin);
1. 根据文件指针的位置和偏移量来定位文件指针。

2. 控制 stream 文件指针从 origin 开始偏移 offset。

3. 文件指针默认在文件起始位置，origin有三个选项控制文件指针的起始位置。

例子

文件指针默认指向起始位置也就a，我想访问c。
int main()
{
    FILE* pf = fopen("data.txt", "r");
    if (pf == NULL)
    {
        perror("fopen");
        return 1;
    }

    fseek(pf, -2, SEEK_END); 
    printf("%c\n", fgetc(pf));

    fclose(pf);
    pf = NULL;
}

2. ftell

long int ftell(FILE* stream);

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

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

    printf("%c\n", fgetc(pf));
    printf("%c\n", fgetc(pf));
    printf("%c\n", fgetc(pf));
    printf("%d\n", ftell(pf));

    fclose(pf);
    pf = NULL;
}

3. rewind

void rewind(FILE* stream);

让文件指针的位置回到文件的起始位置。

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

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

    fclose(pf);
    pf = NULL;
}

文本文件，二进制文件

1. 根据数据的组织形式，数据文件被分为文本文件与二进制文件。

2. 数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。

3. 如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

.

一个数据在内存中是怎么存储的呢？

1. 字符一律以ASCII形式存储。

2. 数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

3. 如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节(每个字符一个字节)，而二进制形式输出，则在磁盘上只占4个字节。

二进制编辑器打开

文件读取结束的判定

1. 文本文件读取结束的判断

用 fgetc 判断返回值是否为 EOF 或用 fgets 判断返回值是否为 NULL。

.

2. 二进制文件读取结束的判断

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

.

3. 正确使用 feof

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

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

文件缓冲区

1. 系统会自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。

2. 从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。

3. 如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输到内存缓冲区，充满缓冲区后再从缓冲区逐个地将数据送到程序数据区(程序变量等)。

4. 缓冲区的大小根据编译器决定的。

.

这样做的原因：

1. 当我们使用读写函数的时候，这些函数底层会调用操作系统的接口，让操作系统帮我们读写数据。

2. 实际上操作系统运行着很多进程，如果我们频繁使用这些函数，就会频繁的打断操作系统，这样操作系统就罢工了。

3. 所以我们设一个缓冲区，放满了才去麻烦操作系统。

.

例子

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

标签：文件,pFile,int,读写,C语言,char,pf,FILE
From： https://blog.csdn.net/m0_71164215/article/details/140686326