【C语言标准库函数】标准输入输出函数详解[4]：二进制文件读写函数

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

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) {
    // 1. 参数合法性校验：空指针、无效大小直接返回0
    if (ptr == NULL || stream == NULL || size == 0 || nmemb == 0) {
        return 0;
    }

    // 2. 计算总需读取的字节数
    size_t total_bytes = size * nmemb;
    // 3. 转换为unsigned char*，确保逐字节操作（避免类型对齐问题）
    unsigned char *buf = (unsigned char *)ptr;
    size_t bytes_read = 0; // 已读取的字节数

    // 4. 循环读取字节：处理部分读取场景（如IO中断、文件末尾）
    while (bytes_read < total_bytes) {
        // 底层系统调用：从文件流读取部分字节（模拟OS IO接口）
        size_t read_now = sys_read(stream->fd, buf + bytes_read, total_bytes - bytes_read);
        
        if (read_now == 0) { // 读取到0字节：文件末尾或错误
            break;
        }
        bytes_read += read_now;
    }

    // 5. 处理读取结果：设置文件流状态（错误/EOF）
    if (bytes_read % size != 0) { // 读取字节数不是size的整数倍：数据不完整
        stream->error = 1;
    } else if (bytes_read < total_bytes && !stream->eof) { // 未到末尾但读取中断：错误
        stream->error = 1;
    }

    // 6. 返回实际读取的数据项个数（总字节数 / 每个数据项大小）
    return bytes_read / size;
}

// 读取PNG图片文件到内存
unsigned char *read_png(const char *path, long *file_size) {
    FILE *fp = fopen(path, "rb");
    if (fp == NULL) {
        perror("fopen failed");
        return NULL;
    }

    // 1. 获取文件大小（移动到文件末尾）
    fseek(fp, 0, SEEK_END);
    *file_size = ftell(fp);
    fseek(fp, 0, SEEK_SET); // 恢复文件指针到开头

    // 2. 动态分配缓冲区（存储整个图片）
    unsigned char *png_data = (unsigned char *)malloc(*file_size);
    if (png_data == NULL) {
        fclose(fp);
        return NULL;
    }

    // 3. 读取全部字节：size=1（每个数据项1字节），nmemb=file_size
    size_t read = fread(png_data, 1, *file_size, fp);
    if (read != *file_size) {
        perror("fread failed");
        free(png_data);
        png_data = NULL;
    }

    fclose(fp);
    return png_data;
}

// 定义传感器数据结构体
typedef struct {
    int sensor_id;       // 传感器ID
    float temperature;   // 温度值
    long timestamp;      // 采集时间戳
} SensorData;

// 从文件读取多个传感器数据
SensorData *read_sensor_data(const char *path, int *count) {
    FILE *fp = fopen(path, "rb");
    if (fp == NULL) return NULL;

    // 1. 计算文件中结构体个数
    fseek(fp, 0, SEEK_END);
    long file_size = ftell(fp);
    *count = file_size / sizeof(SensorData);
    fseek(fp, 0, SEEK_SET);

    // 2. 分配内存
    SensorData *data = (SensorData *)malloc(*count * sizeof(SensorData));
    if (data == NULL) {
        fclose(fp);
        return NULL;
    }

    // 3. 批量读取结构体
    size_t read = fread(data, sizeof(SensorData), *count, fp);
    if (read != *count) {
        perror("read sensor data failed");
        free(data);
        data = NULL;
    }

    fclose(fp);
    return data;
}

#define BUF_SIZE 1024*1024 // 1MB缓冲区
void process_large_file(const char *path) {
    FILE *fp = fopen(path, "rb");
    if (fp == NULL) return;

    unsigned char buf[BUF_SIZE];
    size_t read_bytes;

    // 循环分块读取，直到文件末尾
    while ((read_bytes = fread(buf, 1, BUF_SIZE, fp)) > 0) {
        // 处理当前块数据（如解析、过滤、写入其他文件）
        process_block(buf, read_bytes);
        
        // 检查读取错误
        if (ferror(fp)) {
            perror("fread error");
            break;
        }
    }

    fclose(fp);
}

size_t read = fread(data, sizeof(int), 10, fp);
if (read < 10) {
    if (feof(fp)) {
        printf("警告：未读取到10个数据，已到达文件末尾\n");
    } else if (ferror(fp)) {
        perror("错误：读取文件失败");
    }
}

#pragma pack(1) // 强制1字节对齐（取消填充）
typedef struct {
    char a;
    int b;
} AlignTest;
#pragma pack() // 恢复默认对齐

// 读取大端字节序的int值（如网络传输的二进制数据）
int read_big_endian_int(FILE *fp) {
    unsigned char buf[4];
    fread(buf, 1, 4, fp);
    // 大端转小端：buf[0]是高位字节，buf[3]是低位字节
    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}

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

#define DATA_COUNT 100 // 计划读取的整数个数

int main() {
    const char *filename = "numbers.bin";
    FILE *fp = NULL;
    int *data = NULL;
    size_t read_count = 0;
    int sum = 0;
    float avg = 0.0f;

    // 1. 分配缓冲区：存储100个int
    data = (int *)malloc(DATA_COUNT * sizeof(int));
    if (data == NULL) {
        fprintf(stderr, "malloc failed: 内存分配失败\n");
        return EXIT_FAILURE;
    }
    memset(data, 0, DATA_COUNT * sizeof(int)); // 初始化缓冲区

    // 2. 以二进制读取模式打开文件
    fp = fopen(filename, "rb");
    if (fp == NULL) {
        perror("fopen failed");
        free(data);
        return EXIT_FAILURE;
    }

    // 3. 读取数据：每个数据项4字节（sizeof(int)），共100个
    read_count = fread(data, sizeof(int), DATA_COUNT, fp);
    if (read_count == 0) {
        perror("fread failed");
        fclose(fp);
        free(data);
        return EXIT_FAILURE;
    }

    // 4. 处理数据：计算平均值
    for (size_t i = 0; i < read_count; i++) {
        sum += data[i];
    }
    avg = (float)sum / read_count;
    printf("成功读取%d个整数，平均值：%.2f\n", (int)read_count, avg);

    // 5. 检查是否读取到文件末尾
    if (feof(fp)) {
        printf("提示：已到达文件末尾，实际读取个数：%zu（计划：%d）\n", read_count, DATA_COUNT);
    }

    // 6. 释放资源（顺序：先关文件，再释放内存）
    fclose(fp);
    free(data);
    data = NULL; // 避免野指针

    return EXIT_SUCCESS;
}

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

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) {
    // 1. 参数合法性校验
    if (ptr == NULL || stream == NULL || size == 0 || nmemb == 0) {
        return 0;
    }

    // 2. 计算总需写入的字节数
    size_t total_bytes = size * nmemb;
    const unsigned char *buf = (const unsigned char *)ptr; // 只读缓冲区
    size_t bytes_written = 0; // 已写入的字节数

    // 3. 循环写入：处理部分写入场景（如磁盘满、IO中断）
    while (bytes_written < total_bytes) {
        size_t write_now = sys_write(stream->fd, buf + bytes_written, total_bytes - bytes_written);
        
        if (write_now == 0) { // 写入失败
            stream->error = 1;
            break;
        }
        bytes_written += write_now;
    }

    // 4. 返回实际写入的数据项个数
    return bytes_written / size;
}

// 保存用户配置到二进制文件
typedef struct {
    int screen_width;  // 屏幕宽度
    int screen_height; // 屏幕高度
    int volume;        // 音量
    int fullscreen;    // 是否全屏（0/1）
} Config;

int save_config(const Config *config, const char *path) {
    if (config == NULL || path == NULL) return -1;

    FILE *fp = fopen(path, "wb");
    if (fp == NULL) {
        perror("fopen failed");
        return -1;
    }

    // 写入整个结构体
    size_t written = fwrite(config, sizeof(Config), 1, fp);
    if (written != 1) {
        perror("fwrite failed");
        fclose(fp);
        return -1;
    }

    fclose(fp);
    return 0;
}

// 使用示例
Config user_config = {1920, 1080, 80, 1};
save_config(&user_config, "config.bin");

// 保存网络接收的二进制数据到文件
void save_network_data(const unsigned char *data, size_t len, const char *path) {
    FILE *fp = fopen(path, "ab"); // 追加模式：避免覆盖已有数据
    if (fp == NULL) {
        perror("fopen failed");
        return;
    }

    size_t written = fwrite(data, 1, len, fp);
    if (written != len) {
        perror("fwrite failed");
        fclose(fp);
        return;
    }

    fflush(fp); // 强制刷新缓冲区：确保数据立即写入磁盘
    fclose(fp);
}

// 二进制日志结构体
typedef struct {
    long timestamp;    // 时间戳（毫秒）
    int log_level;     // 日志级别（0=DEBUG,1=INFO,2=ERROR）
    char message[256]; // 日志内容
} BinaryLog;

// 写入二进制日志
void write_binary_log(const BinaryLog *log, const char *log_path) {
    FILE *fp = fopen(log_path, "ab");
    if (fp == NULL) return;

    // 批量写入（支持一次写入多个日志条目）
    fwrite(log, sizeof(BinaryLog), 1, fp);
    fflush(fp); // 高并发场景需强制刷新，避免日志丢失
    fclose(fp);
}

char *str = "Hello, Binary!";
// 正确：写入字符串有效长度（不含'\0'）
fwrite(str, 1, strlen(str), fp);

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

// 定义学生信息结构体（设置1字节对齐，确保跨平台兼容）
#pragma pack(1)
typedef struct {
    int id;          // 学号
    char name[20];   // 姓名
    float score;     // 成绩
} Student;
#pragma pack()

#define STUDENT_COUNT 3 // 学生人数

int main() {
    const char *filename = "students.bin";
    FILE *fp = NULL;
    Student students[STUDENT_COUNT] = {
        {101, "Zhang San", 95.5f},
        {102, "Li Si", 88.0f},
        {103, "Wang Wu", 92.3f}
    };
    Student read_students[STUDENT_COUNT] = {0};
    size_t written, read;

    // -------------------------- 第一步：写入数据 --------------------------
    fp = fopen(filename, "wb");
    if (fp == NULL) {
        perror("fopen for write failed");
        return EXIT_FAILURE;
    }

    // 写入3个学生结构体
    written = fwrite(students, sizeof(Student), STUDENT_COUNT, fp);
    if (written != STUDENT_COUNT) {
        perror("fwrite failed");
        fclose(fp);
        return EXIT_FAILURE;
    }
    printf("成功写入%d个学生数据\n", (int)written);

    fflush(fp); // 强制刷新缓冲区
    fclose(fp);
    fp = NULL;

    // -------------------------- 第二步：读取数据 --------------------------
    fp = fopen(filename, "rb");
    if (fp == NULL) {
        perror("fopen for read failed");
        return EXIT_FAILURE;
    }

    // 读取3个学生结构体
    read = fread(read_students, sizeof(Student), STUDENT_COUNT, fp);
    if (read != STUDENT_COUNT) {
        perror("fread failed");
        fclose(fp);
        return EXIT_FAILURE;
    }
    printf("成功读取%d个学生数据\n", (int)read);

    // -------------------------- 第三步：验证数据一致性 --------------------------
    for (int i = 0; i < STUDENT_COUNT; i++) {
        assert(read_students[i].id == students[i].id);
        assert(strcmp(read_students[i].name, students[i].name) == 0);
        assert(read_students[i].score - students[i].score < 1e-6); // float精度允许误差
        printf("学生%d：ID=%d, 姓名=%s, 成绩=%.1f\n",
               i+1, read_students[i].id, read_students[i].name, read_students[i].score);
    }

    fclose(fp);
    printf("数据写入与读取一致，验证通过！\n");

    return EXIT_SUCCESS;
}

#pragma pack(1)
typedef struct { int id; char name[20]; } User;
#pragma pack()

// 写入时：主机序→网络序
int32_t net_id = htonl(user.id);
fwrite(&net_id, sizeof(int32_t), 1, fp);
// 读取时：网络序→主机序
int32_t net_id;
fread(&net_id, sizeof(int32_t), 1, fp);
user.id = ntohl(net_id);