c语言操作文件

1、文件缓冲区

文件缓冲区的目的：提高访问效率 提高磁盘使用寿命
刷新就是将当前缓冲区数据全部提交。
不刷新时，程序在崩溃时缓冲区内容无法输出（有些情形会带来错误）

文件缓冲区的四种刷新方式

行刷新（遇到换行符刷新）

#include <stdio.h>
#include <stdlib.h>
void test()
{
    printf("画押！");
    while (1)
    {
        ;
    }
}

int main(int argc, char const *argv[])
{
    test();
    return 0;
}

编译输出的时候没有输出任何信息，是因为没有使用 换行符号 刷新缓冲区

在printf中添加换行符号打印输出正常！

满刷新（缓冲区放满数据刷新）

缓冲区放满数据之后就会强制刷新缓冲区

强制刷新（不管缓冲区满不满，使用fflush将缓冲区强制刷新）

关闭刷新（关闭文件的时候，将缓冲区的数据全部刷新）

函数执行完毕的时候，也就是关闭执行文件的时候刷新缓冲区数据，提交数据

模拟时钟

void test()
{
    int i = 0;
    while (1)
    {
        printf("\r%02d:%02d", i / 60, i % 60);
        sleep(1);
        i++;
    }
}

2、文件的API

文件的操作步骤：打开、读写、关闭

打开文件 fopen

#include <stdio.h>
FILE *fopen(const char *path, const char *mode);

path：文件的路径
mode：打开文件的方式
返回值：
成功：打开的文件指针
失败：NULL
函数说明：fopen是打开一个已经存在的文件，并返回这个文件的文件指针（文件的标识）或者创建一个文件，并打开此文件，并返回文件的标识
文件的打开方式mode：r w a + t b
r：只读的方式打开
w：只写的方式打开
a：追加的方式打开
+：可读可写的方式打开
t：以文本文件的方式打开（默认是省略的）
b：以二进制方式打开（必须显示说明）
组合方式：

w模式，希望是一个干净的文件，所以若存在同名文件就会删除已经存在的文件，重新创建该文件进行操作，所以谨慎使用
r+中+就是可读可写，但是r强调的是不创建新文件，如果没有r并且文件不存在就会创建新文件

w+或者wb+模式，希望是一个干净的文件，所以若存在同名文件就会删除已经存在的文件，重新创建该文件进行操作，所以谨慎使用

关闭文件 fopen

关闭保存文件信息的空间

#include <stdio.h>
int fclose(FILE *stream);    //只需要传递一个文件指针

成功：返回 1
失败：返回 0

3、一次读写一个文件

一次写一个字节

#include <stdio.h>
#include <stdlib.h>
void test()
{
    FILE *fp = NULL;
    fp = fopen("ml.txt", "w");
    if (fp == NULL)
    {
        perror("fopen");
        return; // 防止出现段错误，因为要是文件不存在的话，那就是一个空指针，下面直接操作空指针会出现段错误
    }
    char *f_data = "我是小明！";
    while (*f_data != '\0')
    {
        fputc(*f_data, fp);
        f_data++;
    }
    fclose(fp);
}

int main(int argc, char const *argv[])
{
    test();
    return 0;
}

4、一次读一个字节

将上面的ml.txt文件一次一个字节读出

int fgetc(FILE *stream);
//从所标识的文件中读取一个字节，将字节值返回
//返回值   ：
      //以t 的方式，读到文件结尾返回 EOF
      //以b 的方式，读到文件结尾，使用feof判断结尾

void test1() // 一次读一个字节
{
    FILE *fp = NULL;
    fp = fopen("ml.txt", "r");
    if (fp == NULL)
    {
        perror("fopen");
        return; // 防止出现段错误，因为要是文件不存在的话，那就是一个空指针，下面直接操作空指针会出现段错误
    }
    // 当然也可以读一个打印一个字符
    // char f_data[128] = "";
    //  不能写成 char *f_data = ""这是文字常量区来存读取的数据

    while (1)
    {
        char ch = fgetc(fp);
        if (ch == EOF)    //EOF并不是文件中存在的，而是指针到达文件末尾的时候会自动判断出来，加上EOF
        {
            break;
        }
        printf("%c", ch);
    }
    printf("\n");
    fclose(fp);
}

int main(int argc, char const *argv[])
{
    test1();
    return 0;
}

5、一次读写一个字符串

读取一个字符串，遇到换行符结束，读取一行文件数据

char *fgets(const char *s,FILE *stream);
//成功：返回目的数组的首地址，即s
//失败：返回空

写：
将一个文件中数据读出写入到另一个文件中

char *fgets(const char *s,FILE *stream);

#include <stdio.h>
#include <stdlib.h>
void test()
{
    FILE *fp_r = NULL;
    fp_r = fopen("ml.txt", "r"); // 从ml.txt中读出数据
    if (fp_r == NULL)
    {
        perror("fopen");
        return; // 防止出现段错误，因为要是文件不存在的话，那就是一个空指针，下面直接操作空指针会出现段错误
    }

    FILE *fp_w = NULL;
    fp_w = fopen("b.txt", "w"); // 向b.txt文件中写入数据
    if (fp_w == NULL)
    {
        perror("fopen");
        return; // 防止出现段错误，因为要是文件不存在的话，那就是一个空指针，下面直接操作空指针会出现段错误
    }

    while (1)
    {
        char buff[128] = ""; // 不能定义 *str = ""来存储读取的数据，因为文字常量区的数据是不能被修改的
        // 将读取到的文件数据存放在数组中
        char *ret = fgets(buff, sizeof(buff), fp_r);
        if (ret == NULL)
        {
            break;
        }
        // 将数组中的数据写入到文件某种
        fputs(buff, fp_w);
    }
    fclose(fp_r);
    fclose(fp_w);
}

int main(int argc, char const *argv[])
{
    test();
    return 0;
}

读文件的时候要定义一个字符数组接收读出的数据，然后将该字符数组中的数据写入到文字本中

6、一次读写 n 块文件数据

fread 和 fwrite是成对使用的，使用效率高，但是阅读性差

#include <stdio.h>

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

块写：将内存中的数据原样的写入到磁盘文件中，这样操作的速度比较快
块写：将磁盘文件中的数据原样读入到内存中
返回值：实际写入的块数/实际读的块数（整数块数，不足一块不计，但是还是读写了）
ptr ：内存空间地址
size：每一块的字节大小
nmemb：总共有多杀块
stream：要写入的是哪个文件
案例：
定义一个结构体

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    char name[16];
    int atk;
    int def;
} HERO;

定义结构体数组，并且将结构体数组中的数据写入不存在的文件中

void test() // 一次写一个
{
    HERO hero[] = {{"猴子", 99, 100}, {"八戒", 70, 80}, {"沙僧", 50, 60}};
    int n = sizeof(hero) / sizeof(hero[0]);
    FILE *fp = fopen("hero.txt", "w");
    if (fp == NULL)
    {
        perror("fopen");
        return;
    }
    fwrite(hero, sizeof(hero), n, fp);
    fclose(fp);
}

运行生成 hero.txt文件，只不过该文件我们查看不了。因为是将内存中的数据（二进制完全原样写在了文件中）但是不妨碍使用读

#include <string.h>
void read_fun()
{
    HERO hero[3];
    memset(hero, 0, sizeof(hero));
    FILE *fp = fopen("hero.txt", "r");
    if (fp == NULL)
    {
        perror("fopen");
        return;
    }
    fread(hero, sizeof(hero), 3, fp);
    for (int i = 0; i < 3; i++)
    {
        printf("%s\t%d\t%d\n", hero[i].name, hero[i].atk, hero[i].def);
    }
    fclose(fp);
}

int main(int argc, char const *argv[])
{
    read_fun();
    return 0;
}

7、格式化输出函数

fprintf 和fscanf成对使用，使用效率低，但是便于阅读

解决上面使用fprintf和fscanf造成的无法查看，格式很乱的现象
格式化写fprintf

inline int __cdecl fprintf(FILE *const _Stream, const char *const _Format, ...)
inline int __cdecl fscanf(FILE *const _Stream, const char *const _Format, ...)

FILE *const _Stream：文件指针

void fprintf_fun() // 使用格式化写
{
    HERO hero[] = {{"猴子", 99, 100}, {"八戒", 70, 80}, {"沙僧", 50, 60}};
    int n = sizeof(hero) / sizeof(hero[0]);
    FILE *fp = fopen("hero.txt", "w");
    if (fp == NULL)
    {
        perror("fopen");
        return;
    }
    // 一行一行往进去写
    for (int i = 0; i < n; i++)
    {
        fprintf(fp, "%s\t%d\t%d\n", hero[i].name, hero[i].atk, hero[i].def); // printf是写入到控制台，fprintf是写入到文件中
    }
    fclose(fp);
}

void fscanf_fun() // 使用格式化读
{
    HERO hero[3];
    memset(hero, 0, sizeof(hero));
    FILE *fp = fopen("hero.txt", "r");
    if (fp == NULL)
    {
        perror("fopen");
        return;
    }
    for (int i = 0; i < 3; i++)
    {
        fscanf(fp, "%s\t%d\t%d\n", hero[i].name, &hero[i].atk, &hero[i].def);
    }
    for (int i = 0; i < 3; i++)
    {
        printf("%s\t%d\t%d\n", hero[i].name, hero[i].atk, hero[i].def); // 写到控制台
    }
    fclose(fp);
}

int main(int argc, char const *argv[])
{
    fscanf_fun();
    return 0;
}

8、随机读写

文件默认是顺序读写
但是随机读写的话用户可以更改流指针的位置