流水潺潺：探寻Linux下C语言文件流的诗意实现

#define BUFFER_SIZE 1024   //缓冲区大小

//通过位图的方式，控制刷新方式
#define BUFFER_NONE 0x1    //无缓冲
#define BUFFER_LINE 0x2    //行缓冲
#define BUFFER_ALL 0x4     //全缓冲

typedef struct MY_FILE
{
    char _buffer[BUFFER_SIZE];  //缓冲区
    size_t _current;    //缓冲区下标
    int _flush;  //刷新方式，位图结构

    int _fd;    //文件描述符
}MY_FILE;

#include <stdio.h>
#include <assert.h>
#include <string.h>

int main()
{
    //打开文件，写入数据
    FILE* fp = fopen("file.txt", "w");
    assert(fp);

    const char* str = "露易斯湖三面环山，层峦叠嶂，翠绿静谧的湖泊在宏伟山峰及壮观的维多利亚冰川的映照下更加秀丽迷人";
    char buff[1024] = { 0 };
    snprintf(buff, sizeof(buff), str);
    fwrite(buff, 1, sizeof(buff), fp);

    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <assert.h>
#include <string.h>

int main()
{
    //打开文件，并从文件中读取信息
    FILE* fp = fopen("file.txt", "r+");
    assert(fp);

    char buff[1024] = { 0 };
    int n = fread(buff, 1, sizeof(buff) - 1, fp);
    buff[n] = '\0';
    printf("%s", buff);

    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <unistd.h>

int main()
{
    int cnt = 20;
    while(cnt)
    {
        printf("he");   //故意不触发缓冲
        cnt--;
        if(cnt % 10 == 5) 
        {
            fflush(stdout); //刷新缓冲区
            printf("\n当前已冲刷，cnt: %d\n", cnt);
        }
        sleep(1);
    }
    return 0;
}

MY_FILE *my_fopen(const char *path, const char *mode); //打开文件

// 打开文件
MY_FILE *my_fopen(const char *path, const char *mode)
{
    assert(path && mode);

    // 确定打开方式
    int flags = 0; // 打开方式

    // 读：O_RDONLY   读+：O_RDONLY | O_WRONLY
    // 写：O_WRONLY | O_CREAT | O_TRUNC   写+：O_WRONLY | O_CREAT | O_TRUNC | O_RDONLY
    // 追加： O_WRONLY | O_CREAT | O_APPEND   追加+：O_WRONLY | O_CREAT | O_APPEND | O_RDONLY
    // 注意：不考虑 b 二进制读写的情况
    if (*mode == 'r')
    {
        flags |= O_RDONLY;
        if (strcmp("r+", mode) == 0)
            flags |= O_WRONLY;
    }
    else if (*mode == 'w' || *mode == 'a')
    {
        flags |= (O_WRONLY | O_CREAT);

        if (*mode == 'w')
            flags |= O_TRUNC;
        else
            flags |= O_APPEND;

        if (strcmp("w+", mode) == 0 || strcmp("a+", mode) == 0)
            flags |= O_RDONLY;
    }
    else
    {
        // 无效打开方式
        assert(false);
    }

    // 根据打开方式，打开文件
    // 注意新建文件需要设置权限
    int fd = 0;
    if (flags & O_CREAT)
        fd = open(path, flags, 0666);
    else
        fd = open(path, flags);

    if (fd == -1)
    {
        // 打开失败的情况
        return NULL;
    }

    // 打开成功了，创建 MY_FILE 结构体，并返回
    MY_FILE *new_file = (MY_FILE *)malloc(sizeof(MY_FILE));
    if (new_file == NULL)
    {
        // 此处不能断言，需要返回空
        close(fd); // 需要先把 fd 关闭
        perror("malloc FILE fail!");
        return NULL;
    }

    // 初始化 MY_FILE
    memset(new_file->_buffer, '\0', BUFFER_SIZE); // 初始化缓冲区
    new_file->_current = 0;                       // 下标置0
    new_file->_flush = BUFFER_LINE;               // 行刷新
    new_file->_fd = fd;                           // 设置文件描述符

    return new_file;
}

int my_fclose(MY_FILE *fp);   //关闭文件

// 关闭文件
int my_fclose(MY_FILE *fp)
{
    assert(fp);

    // 刷新残余数据
    if (fp->_current > 0)
        my_fflush(fp);

    // 关闭 fd
    int ret = close(fp->_fd);

    // 释放已开辟的空间
    free(fp);
    fp = NULL;

    return ret;
}

int my_fflush(MY_FILE *stream);   //缓冲区刷新

// 缓冲区刷新
int my_fflush(MY_FILE *stream)
{
    assert(stream);

    // 将数据写给文件
    int ret = write(stream->_fd, stream->_buffer, stream->_current);
    stream->_current = 0; // 每次刷新后，都需要清空缓冲区
    fsync(stream->_fd);   // 将内核中的数据强制刷给磁盘(文件)

    if (ret != -1) return 0;
    else return -1;
}

size_t my_fwrite(const void *ptr, size_t size, size_t nmemb, MY_FILE *stream);    //数据写入

// 数据读取
size_t my_fread(void *ptr, size_t size, size_t nmemb, MY_FILE *stream)
{
    // 数据读取前，需要先把缓冲区刷新
    if (stream->_current > 0)
        my_fflush(stream);

    size_t user_size = size * nmemb;
    size_t my_size = BUFFER_SIZE;

    // 先将数据读取到FILE缓冲区中，再赋给 ptr
    if (my_size >= user_size)
    {
        // 此时缓冲区中足够存储用户需要的所有数据，只需要读取一次
        read(stream->_fd, stream->_buffer, my_size);
        memcpy(ptr, stream->_buffer, my_size);
        *((char *)ptr + my_size - 1) = '\0';
    }
    else
    {
        int ret = 1;
        size_t tmp = user_size;
        while (ret)
        {
            // 一次读不完，需要多读取几次
            ret = read(stream->_fd, stream->_buffer, my_size);
            stream->_buffer[ret] = '\0';
            memcpy(ptr + (tmp - user_size), stream->_buffer, my_size);
            stream->_current = 0;
            user_size -= my_size;
        }
    }

    size_t readn = strlen(ptr);

    return readn;
}