C++如何实现文件夹的增量式ZIP压缩备份逻辑

增量式ZIP压缩备份的核心逻辑是仅对上次备份后发生变化的文件进行压缩打包，避免重复处理未修改的文件，从而降低存储开销和备份耗时。实现该逻辑需要结合文件状态记录、变更检测、ZIP压缩操作三个核心模块，下面逐一展开说明。

整体实现流程设计

完整的增量备份流程可以分为四个步骤，每个步骤的职责明确，逻辑耦合度低，方便后续扩展维护：

• 读取上次备份的元数据文件，获取所有已备份文件的路径和最后修改时间戳
• 遍历目标文件夹，对比当前文件的修改时间与元数据中记录的时间，筛选出新增或修改的文件
• 将筛选出的增量文件压缩到新的ZIP包中，支持追加到已有备份包或者生成新的备份包
• 更新元数据文件，记录本次备份的文件信息，供下次备份时使用

核心依赖说明

实现过程中需要用到两个核心依赖：

• C++17及以上标准库：提供文件系统操作接口std::filesystem，用于遍历文件夹、获取文件修改时间
• minizip库：轻量级的ZIP压缩库，支持创建、追加、读取ZIP包，跨平台兼容性好

元数据文件设计

元数据用于记录每次备份的文件状态，采用JSON格式存储，结构如下：

{
    "backup_time": "2024-05-20 14:30:00",
    "files": [
        {
            "path": "test/doc.txt",
            "modify_time": 1716186600
        },
        {
            "path": "test/image.png",
            "modify_time": 1716186600
        }
    ]
}

其中modify_time为文件最后修改时间的时间戳，用于后续变更对比。

核心功能代码实现

1. 获取文件最后修改时间戳

使用std::filesystem获取文件的最后修改时间，并转换为时间戳：

#include <filesystem>
#include <chrono>
#include <ctime>

namespace fs = std::filesystem;

// 获取文件最后修改时间的时间戳
time_t get_file_modify_time(const fs::path& file_path) {
    if (!fs::exists(file_path) || !fs::is_regular_file(file_path)) {
        return 0;
    }
    // 获取文件最后修改时间
    auto ftime = fs::last_write_time(file_path);
    // 转换为time_t类型的时间戳
    auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
        ftime - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
    );
    return std::chrono::system_clock::to_time_t(sctp);
}

2. 读取历史元数据

解析之前备份生成的元数据文件，将文件路径和修改时间存储到哈希表中，方便后续快速查询：

#include <fstream>
#include <unordered_map>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

// 读取历史元数据，返回文件路径到修改时间的映射
std::unordered_map<std::string, time_t> load_history_metadata(const std::string& meta_path) {
    std::unordered_map<std::string, time_t> history_map;
    if (!fs::exists(meta_path)) {
        return history_map;
    }
    std::ifstream meta_file(meta_path);
    if (!meta_file.is_open()) {
        return history_map;
    }
    json meta_json;
    meta_file >> meta_json;
    meta_file.close();
    if (meta_json.contains("files") && meta_json["files"].is_array()) {
        for (const auto& item : meta_json["files"]) {
            std::string file_path = item["path"];
            time_t modify_time = item["modify_time"];
            history_map[file_path] = modify_time;
        }
    }
    return history_map;
}

3. 检测增量文件

遍历目标文件夹，对比历史元数据，筛选出需要备份的增量文件：

#include <vector>

// 检测目标文件夹中的增量文件，返回需要备份的文件路径列表
std::vector<fs::path> detect_incremental_files(
    const fs::path& target_dir,
    const std::unordered_map<std::string, time_t>& history_map
) {
    std::vector<fs::path> incremental_files;
    if (!fs::exists(target_dir) || !fs::is_directory(target_dir)) {
        return incremental_files;
    }
    // 递归遍历目标文件夹
    for (const auto& entry : fs::recursive_directory_iterator(target_dir)) {
        if (!fs::is_regular_file(entry.status())) {
            continue;
        }
        fs::path file_path = entry.path();
        // 获取相对路径，避免绝对路径导致元数据无法跨环境使用
        fs::path relative_path = fs::relative(file_path, target_dir);
        std::string rel_path_str = relative_path.string();
        time_t current_mtime = get_file_modify_time(file_path);
        // 判断是否为新增或修改的文件
        auto it = history_map.find(rel_path_str);
        if (it == history_map.end() || it->second != current_mtime) {
            incremental_files.push_back(file_path);
        }
    }
    return incremental_files;
}

4. 增量文件压缩到ZIP

使用minizip库将增量文件压缩到ZIP包中，支持追加到已有的ZIP包：

#include <zip.h>

// 将增量文件压缩到ZIP包，append为true时追加到已有ZIP包
bool compress_incremental_files(
    const std::vector<fs::path>& incremental_files,
    const fs::path& target_dir,
    const std::string& zip_path,
    bool append = true
) {
    zipFile zf = nullptr;
    if (append && fs::exists(zip_path)) {
        // 追加模式打开ZIP包
        zf = zipOpen(zip_path.c_str(), APPEND_STATUS_ADDINZIP);
    } else {
        // 新建ZIP包
        zf = zipOpen(zip_path.c_str(), APPEND_STATUS_CREATE);
    }
    if (zf == nullptr) {
        return false;
    }
    for (const auto& file_path : incremental_files) {
        fs::path relative_path = fs::relative(file_path, target_dir);
        std::string rel_path_str = relative_path.string();
        // 打开要压缩的文件
        FILE* src_file = fopen(file_path.string().c_str(), "rb");
        if (src_file == nullptr) {
            continue;
        }
        // 获取文件大小
        fseek(src_file, 0, SEEK_END);
        long file_size = ftell(src_file);
        fseek(src_file, 0, SEEK_SET);
        // 写入ZIP文件信息
        zip_fileinfo zi = {0};
        zipOpenNewFileInZip(zf, rel_path_str.c_str(), &zi, nullptr, 0, nullptr, 0, nullptr, Z_DEFLATED, Z_DEFAULT_COMPRESSION);
        // 读取文件内容并写入ZIP
        char buffer[4096];
        size_t read_len = 0;
        while ((read_len = fread(buffer, 1, sizeof(buffer), src_file)) > 0) {
            zipWriteInFileInZip(zf, buffer, read_len);
        }
        zipCloseFileInZip(zf);
        fclose(src_file);
    }
    zipClose(zf, nullptr);
    return true;
}

5. 更新元数据文件

备份完成后，更新元数据文件，记录本次所有备份文件的状态：

// 更新元数据文件，记录本次备份的所有文件信息
void update_metadata(
    const fs::path& target_dir,
    const std::vector<fs::path>& all_backup_files,
    const std::string& meta_path
) {
    json meta_json;
    // 获取当前时间作为备份时间
    auto now = std::chrono::system_clock::now();
    time_t now_time = std::chrono::system_clock::to_time_t(now);
    char time_str[64];
    struct tm* time_info = localtime(&now_time);
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", time_info);
    meta_json["backup_time"] = time_str;
    meta_json["files"] = json::array();
    for (const auto& file_path : all_backup_files) {
        fs::path relative_path = fs::relative(file_path, target_dir);
        std::string rel_path_str = relative_path.string();
        time_t mtime = get_file_modify_time(file_path);
        meta_json["files"].push_back({
            {"path", rel_path_str},
            {"modify_time", mtime}
        });
    }
    std::ofstream meta_file(meta_path);
    meta_file << meta_json.dump(4);
    meta_file.close();
}

完整调用示例

将上述模块组合起来，实现一次完整的增量备份操作：

int main() {
    fs::path target_dir = "./test_dir"; // 要备份的目标文件夹
    std::string zip_path = "./backup.zip"; // 备份ZIP包路径
    std::string meta_path = "./backup_meta.json"; // 元数据文件路径

    // 1. 加载历史元数据
    auto history_map = load_history_metadata(meta_path);
    // 2. 检测增量文件
    auto incremental_files = detect_incremental_files(target_dir, history_map);
    if (incremental_files.empty()) {
        printf("没有检测到需要备份的增量文件n");
        return 0;
    }
    // 3. 压缩增量文件到ZIP包
    bool compress_ok = compress_incremental_files(incremental_files, target_dir, zip_path, true);
    if (!compress_ok) {
        printf("增量文件压缩失败n");
        return -1;
    }
    // 4. 收集所有已备份的文件（历史+本次增量）
    std::vector<fs::path> all_backup_files;
    for (const auto& entry : fs::recursive_directory_iterator(target_dir)) {
        if (fs::is_regular_file(entry.status())) {
            all_backup_files.push_back(entry.path());
        }
    }
    // 5. 更新元数据
    update_metadata(target_dir, all_backup_files, meta_path);
    printf("增量备份完成，本次备份文件数量：%zun", incremental_files.size());
    return 0;
}

注意事项

• 文件路径建议使用相对路径存储，避免元数据在不同机器或不同目录下无法使用
• 文件修改时间对比可能存在精度问题，可根据需求增加文件大小二次校验
• minizip库需要提前编译并链接到项目中，Windows下可使用vcpkg安装，Linux下可使用apt安装libminizip-dev
• 大文件压缩时建议增加进度回调，避免备份过程无响应

C++ZIP_compressionincremental_backupfile_monitoring修改时间：2026-07-22 22:09:20