C++如何实现文件操作的回滚机制 事务性文件处理设计

#include <iostream>
#include <fstream>
#include <string>
#include <filesystem> // C++17
#include <random>     // For unique temp file name

namespace fs = std::filesystem;

// 模拟一个文件操作，这里是向文件追加一行内容
bool perform_file_modification(const fs::path& temp_filepath, const fs::path& original_filepath, const std::string& new_line_content) {
    std::ifstream original_in(original_filepath);
    if (!original_in.is_open()) {
        std::cerr << "错误：无法打开原始文件进行读取。" << std::endl;
        return false;
    }

    std::ofstream temp_out(temp_filepath);
    if (!temp_out.is_open()) {
        std::cerr << "错误：无法创建或打开临时文件进行写入。" << std::endl;
        original_in.close();
        return false;
    }

    // 复制原始文件内容到临时文件
    temp_out << original_in.rdbuf(); // rdbuf() 是一个高效的复制方式
    if (original_in.bad() || temp_out.bad()) {
        std::cerr << "错误：复制文件内容时发生错误。" << std::endl;
        original_in.close();
        temp_out.close();
        return false;
    }

    // 添加新的内容
    temp_out << new_line_content << std::endl;
    if (temp_out.bad()) {
        std::cerr << "错误：写入新内容到临时文件时发生错误。" << std::endl;
        original_in.close();
        temp_out.close();
        return false;
    }

    original_in.close();
    temp_out.close(); // 确保所有内容都已刷新并关闭文件

    return true;
}

// 模拟一个带有回滚机制的文件更新函数
bool update_file_transactionally(const fs::path& filepath, const std::string& content_to_add) {
    fs::path temp_filepath = filepath.parent_path() / (filepath.filename().string() + ".tmp_" + std::to_string(std::random_device{}()));

    std::cout << "尝试更新文件: " << filepath << std::endl;
    std::cout << "使用临时文件: " << temp_filepath << std::endl;

    bool success = false;
    try {
        if (perform_file_modification(temp_filepath, filepath, content_to_add)) {
            // 所有修改成功写入临时文件，执行原子性替换
            fs::remove(filepath); // 先删除旧文件
            fs::rename(temp_filepath, filepath); // 再重命名临时文件
            std::cout << "文件更新成功，已完成替换。" << std::endl;
            success = true;
        } else {
            std::cerr << "文件修改操作失败，将尝试清理临时文件。" << std::endl;
        }
    } catch (const fs::filesystem_error& e) {
        std::cerr << "文件系统操作异常: " << e.what() << std::endl;
    }

    // 无论成功与否，都要清理临时文件
    if (fs::exists(temp_filepath)) {
        try {
            fs::remove(temp_filepath);
            std::cout << "临时文件已清理: " << temp_filepath << std::endl;
        } catch (const fs::filesystem_error& e) {
            std::cerr << "错误：无法清理临时文件: " << e.what() << std::endl;
        }
    }
    return success;
}

/*
// 示例用法（不作为输出的一部分，仅供参考）
int main() {
    fs::path my_file = "my_data.txt";

    // 创建一个初始文件
    {
        std::ofstream ofs(my_file);
        ofs << "Line 1\n";
        ofs << "Line 2\n";
    }

    std::cout << "--- 第一次更新（成功）---" << std::endl;
    if (update_file_transactionally(my_file, "Line 3 (added successfully)")) {
        std::cout << "文件内容应包含 Line 3。" << std::endl;
    } else {
        std::cout << "文件内容应保持不变。" << std::endl;
    }

    std::cout << "\n--- 第二次更新（模拟失败）---" << std::endl;
    // 模拟一个失败场景，例如在 perform_file_modification 中抛出异常或返回false
    // 这里为了演示，我们直接让 perform_file_modification 返回 false
    // 实际中可能需要更复杂的模拟，比如在写入中途强制关闭文件流等
    // 为了简化，此处不直接模拟内部失败，仅展示外部调用时的清理逻辑
    // 假设 perform_file_modification 内部逻辑复杂，可能在某个地方返回 false
    // 比如：bool perform_file_modification(...) { if (rand() % 2 == 0) return false; ... }

    // 为了演示回滚，我们直接删除原始文件来模拟更新失败，看临时文件是否被清理
    // 这是一个不真实的失败模拟，仅为演示清理逻辑
    // fs::remove(my_file); // 模拟原始文件在操作中途丢失，导致rename失败

    if (update_file_transactionally(my_file, "Line 4 (should not appear if failed)")) {
         std::cout << "文件内容应包含 Line 4。" << std::endl;
    } else {
        std::cout << "文件内容应保持不变。" << std::endl;
    }

    std::cout << "\n--- 最终文件内容 ---" << std::endl;
    std::ifstream final_in(my_file);
    if (final_in.is_open()) {
        std::cout << final_in.rdbuf() << std::endl;
    } else {
        std::cout << "文件不存在或无法打开。" << std::endl;
    }

    return 0;
}
*/