在跨平台C层中如何实现类fopen的二进制与文本模式功能？

一、文本与二进制模式的核心差异 #

这俩模式的本质区别是换行符处理逻辑，不同平台差异明显：

• Windows：
  • 文本模式：读取时自动把文件中的\r\n（Windows标准换行）转换成C语言的\n；写入时把代码里的\n转换成\r\n写入文件。另外文本模式会把0x1A（DOS EOF标记）视为文件结束，读到该字符就停止读取。
  • 二进制模式：完全不做任何字节转换，原样读写文件内容，也不会将0x1A识别为EOF。
• Linux/Unix类系统：
  系统本身就用\n作为换行符，因此文本和二进制模式无底层差异，系统不会对字节做任何额外处理。

二、基于底层API的实现方案 #

你计划用Windows的CreateFile和Linux的open实现跨平台文件操作，下面分平台给出具体实现逻辑：

1. Windows平台（CreateFile） #

CreateFile本身没有文本/二进制模式的开关，需要在读写环节自行处理换行符转换。先定义统一的文件结构体，再封装打开、读写、关闭函数：

定义跨平台文件结构体

#ifdef _WIN32
#include <windows.h>
#include <string.h>
#include <stdlib.h>

typedef struct {
    HANDLE handle;
    int is_text; // 1=文本模式，0=二进制模式
} MyFile;
#else
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

typedef struct {
    int fd;
    int is_text; // Linux下无用，仅为接口统一保留
} MyFile;
#endif

实现打开函数

解析mode字符串（如"r"、"rb"、"w"），设置对应的CreateFile参数，并标记当前模式：

MyFile* my_fopen(const char* path, const char* mode) {
    MyFile* file = malloc(sizeof(MyFile));
    if (!file) return NULL;

#ifdef _WIN32
    DWORD desired_access = 0;
    DWORD creation_disposition = 0;
    file->is_text = !(strchr(mode, 'b')); // 未指定'b'则为文本模式

    // 解析读写模式
    if (strchr(mode, 'r')) {
        desired_access = GENERIC_READ;
        creation_disposition = OPEN_EXISTING;
    } else if (strchr(mode, 'w')) {
        desired_access = GENERIC_READ | GENERIC_WRITE;
        creation_disposition = CREATE_ALWAYS;
    } else if (strchr(mode, 'a')) {
        desired_access = GENERIC_WRITE;
        creation_disposition = OPEN_ALWAYS;
    } else {
        free(file);
        return NULL;
    }

    file->handle = CreateFileA(
        path,
        desired_access,
        FILE_SHARE_READ,
        NULL,
        creation_disposition,
        FILE_ATTRIBUTE_NORMAL,
        NULL
    );

    if (file->handle == INVALID_HANDLE_VALUE) {
        free(file);
        return NULL;
    }
#else
    int flags = 0;
    file->is_text = 0; // Linux下忽略模式差异

    if (strchr(mode, 'r')) {
        flags = O_RDONLY;
    } else if (strchr(mode, 'w')) {
        flags = O_WRONLY | O_CREAT | O_TRUNC;
    } else if (strchr(mode, 'a')) {
        flags = O_WRONLY | O_CREAT | O_APPEND;
    } else {
        free(file);
        return NULL;
    }

    file->fd = open(path, flags, 0644);
    if (file->fd == -1) {
        free(file);
        return NULL;
    }
#endif

    return file;
}

实现读取函数（处理文本模式转换）

文本模式下需将\r\n转换为\n，并识别0x1A为EOF：

size_t my_fread(void* ptr, size_t size, size_t nmemb, MyFile* file) {
    if (!file) return 0;

#ifdef _WIN32
    if (!file->is_text) {
        // 二进制模式直接读取
        DWORD bytes_read;
        if (!ReadFile(file->handle, ptr, size * nmemb, &bytes_read, NULL)) {
            return 0;
        }
        return bytes_read / size;
    } else {
        // 文本模式：转换\r\n为\n，处理0x1A
        char* temp_buf = malloc(size * nmemb + 1);
        if (!temp_buf) return 0;

        DWORD bytes_read;
        if (!ReadFile(file->handle, temp_buf, size * nmemb, &bytes_read, NULL)) {
            free(temp_buf);
            return 0;
        }

        char* dst = (char*)ptr;
        size_t dst_idx = 0;
        for (size_t i = 0; i < bytes_read; i++) {
            if (temp_buf[i] == '\r' && i + 1 < bytes_read && temp_buf[i+1] == '\n') {
                dst[dst_idx++] = '\n';
                i++; // 跳过后续的\n
            } else if (temp_buf[i] == 0x1A) {
                // 文本模式下遇到EOF标记，停止读取
                break;
            } else {
                dst[dst_idx++] = temp_buf[i];
            }
        }

        free(temp_buf);
        return dst_idx / size;
    }
#else
    // Linux下直接读取，无模式差异
    ssize_t bytes_read = read(file->fd, ptr, size * nmemb);
    return bytes_read > 0 ? bytes_read / size : 0;
#endif
}

实现写入函数（处理文本模式转换）

文本模式下需将\n转换为\r\n：

size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, MyFile* file) {
    if (!file) return 0;

#ifdef _WIN32
    if (!file->is_text) {
        // 二进制模式直接写入
        DWORD bytes_written;
        if (!WriteFile(file->handle, ptr, size * nmemb, &bytes_written, NULL)) {
            return 0;
        }
        return bytes_written / size;
    } else {
        // 文本模式：转换\n为\r\n
        const char* src = (const char*)ptr;
        size_t src_len = size * nmemb;
        // 最坏情况所有字符都是\n，需要双倍空间
        char* temp_buf = malloc(src_len * 2);
        if (!temp_buf) return 0;

        size_t dst_idx = 0;
        for (size_t i = 0; i < src_len; i++) {
            if (src[i] == '\n') {
                temp_buf[dst_idx++] = '\r';
                temp_buf[dst_idx++] = '\n';
            } else {
                temp_buf[dst_idx++] = src[i];
            }
        }

        DWORD bytes_written;
        if (!WriteFile(file->handle, temp_buf, dst_idx, &bytes_written, NULL)) {
            free(temp_buf);
            return 0;
        }

        free(temp_buf);
        // 计算实际写入的原始元素个数：减去转换时多写的字节数（每个\n多写1字节）
        size_t newline_count = 0;
        for (size_t i = 0; i < src_len; i++) {
            if (src[i] == '\n') newline_count++;
        }
        size_t original_bytes_written = bytes_written - newline_count;
        return original_bytes_written / size;
    }
#else
    // Linux下直接写入，无模式差异
    ssize_t bytes_written = write(file->fd, ptr, size * nmemb);
    return bytes_written > 0 ? bytes_written / size : 0;
#endif
}

实现关闭函数

int my_fclose(MyFile* file) {
    if (!file) return -1;

#ifdef _WIN32
    BOOL success = CloseHandle(file->handle);
    free(file);
    return success ? 0 : -1;
#else
    int success = close(file->fd);
    free(file);
    return success;
#endif
}

2. Linux平台（open） #

Linux下文本和二进制模式无差异，打开时直接忽略mode里的b标记即可，读写逻辑和二进制模式完全一致，上面的代码已兼容这种情况。

三、注意事项 #

• 上述代码为简化实现，实际开发中需要处理更多边界情况：比如读取到文件末尾时的部分转换、写入时的部分失败、大文件的分块处理等。
• Windows文本模式默认使用系统本地编码（如GBK），若需兼容UTF-8需额外处理，这超出了fopen基础模式的范畴。
• 若不想自行实现转换逻辑，可借助C标准库辅助函数：Windows下用_open_osfhandle将HANDLE转为文件描述符，再用fdopen生成FILE*，直接复用标准库的文本模式转换逻辑，但会依赖C运行时库。

内容的提问来源于stack exchange，提问作者Oh Fiveight