C++17的filesystem怎么用 跨平台文件系统操作的现代方法

#include <iostream>
#include <filesystem> // 核心头文件
#include <fstream>    // 用于文件内容操作

namespace fs = std::filesystem; // 常用别名，方便书写

int main() {
    // 1. 创建路径对象
    fs::path current_path = fs::current_path(); // 获取当前工作目录
    std::cout << "当前工作目录: " << current_path << std::endl;

    fs::path my_dir = current_path / "my_test_dir"; // 路径拼接，自动处理分隔符
    fs::path my_file = my_dir / "example.txt";

    // 2. 检查路径是否存在
    if (!fs::exists(my_dir)) {
        std::cout << "目录不存在，尝试创建: " << my_dir << std::endl;
        try {
            fs::create_directory(my_dir); // 创建单个目录
            // fs::create_directories(my_dir / "sub" / "sub2"); // 如果需要创建多级目录
            std::cout << "目录创建成功。" << std::endl;
        } catch (const fs::filesystem_error& e) {
            std::cerr << "创建目录失败: " << e.what() << std::endl;
            return 1;
        }
    } else {
        std::cout << "目录已存在: " << my_dir << std::endl;
    }

    // 3. 写入文件内容
    if (!fs::exists(my_file)) {
        std::ofstream ofs(my_file); // 使用path对象直接打开文件流
        if (ofs.is_open()) {
            ofs << "Hello, C++17 filesystem!" << std::endl;
            ofs << "This is a test file." << std::endl;
            ofs.close();
            std::cout << "文件创建并写入成功: " << my_file << std::endl;
        } else {
            std::cerr << "无法创建文件: " << my_file << std::endl;
            return 1;
        }
    } else {
        std::cout << "文件已存在: " << my_file << std::endl;
    }

    // 4. 获取文件信息
    if (fs::exists(my_file)) {
        std::cout << "文件大小: " << fs::file_size(my_file) << " 字节" << std::endl;
        std::cout << "是否是普通文件: " << std::boolalpha << fs::is_regular_file(my_file) << std::endl;
        std::cout << "是否是目录: " << std::boolalpha << fs::is_directory(my_file) << std::endl;
        // 获取最后修改时间 (C++20提供了更好的时间处理，这里简单展示)
        auto ftime = fs::last_write_time(my_file);
        // std::cout << "最后修改时间: " << ftime << std::endl; // C++20可以直接输出
    }

    // 5. 遍历目录
    std::cout << "\n遍历目录 '" << my_dir << "':" << std::endl;
    for (const auto& entry : fs::directory_iterator(my_dir)) {
        std::cout << "  - " << entry.path().filename(); // 只显示文件名
        if (fs::is_directory(entry.status())) {
            std::cout << " [目录]";
        } else if (fs::is_regular_file(entry.status())) {
            std::cout << " [文件]";
        }
        std::cout << std::endl;
    }

    // 6. 拷贝文件
    fs::path copied_file = my_dir / "example_copy.txt";
    try {
        fs::copy_file(my_file, copied_file, fs::copy_options::overwrite_existing); // 覆盖已存在的文件
        std::cout << "\n文件拷贝成功: " << copied_file << std::endl;
    } catch (const fs::filesystem_error& e) {
        std::cerr << "拷贝文件失败: " << e.what() << std::endl;
    }

    // 7. 重命名/移动文件
    fs::path renamed_file = my_dir / "renamed_example.txt";
    try {
        fs::rename(copied_file, renamed_file);
        std::cout << "文件重命名成功: " << renamed_file << std::endl;
    } catch (const fs::filesystem_error& e) {
        std::cerr << "重命名文件失败: " << e.what() << std::endl;
    }

    // 8. 删除文件和目录
    // 注意：删除操作不可逆，请谨慎！
    std::cout << "\n清理测试文件和目录..." << std::endl;
    try {
        fs::remove(renamed_file); // 删除文件
        std::cout << "文件删除成功: " << renamed_file << std::endl;
        fs::remove_all(my_dir); // 删除目录及其所有内容
        std::cout << "目录及其内容删除成功: " << my_dir << std::endl;
    } catch (const fs::filesystem_error& e) {
        std::cerr << "删除操作失败: " << e.what() << std::endl;
    }

    return 0;
}

#include <iostream>
#include <filesystem>
#include <fstream>
#include <chrono> // 用于时间比较

namespace fs = std::filesystem;

// 辅助函数：获取文件最后修改时间
std::chrono::file_time_type get_last_write_time(const fs::path& p) {
    std::error_code ec;
    auto time = fs::last_write_time(p, ec);
    if (ec) {
        // 错误处理，比如文件不存在或者权限问题
        std::cerr << "获取文件 '" << p << "' 修改时间失败: " << ec.message() << std::endl;
        // 返回一个非常旧的时间，确保会被更新
        return std::chrono::file_time_type::min();
    }
    return time;
}

void sync_directories(const fs::path& source_dir, const fs::path& target_dir) {
    if (!fs::exists(source_dir) || !fs::is_directory(source_dir)) {
        std::cerr << "源目录不存在或不是目录: " << source_dir << std::endl;
        return;
    }

    // 确保目标目录存在，如果不存在则创建
    if (!fs::exists(target_dir)) {
        std::cout << "目标目录不存在，正在创建: " << target_dir << std::endl;
        std::error_code ec;
        fs::create_directories(target_dir, ec);
        if (ec) {
            std::cerr << "创建目标目录失败: " << ec.message() << std::endl;
            return;
        }
    } else if (!fs::is_directory(target_dir)) {
        std::cerr << "目标路径不是目录: " << target_dir << std::endl;
        return;
    }

    std::cout << "开始同步从 '" << source_dir << "' 到 '" << target_dir << "'..." << std::endl;

    // 遍历源目录下的所有条目（文件和子目录）
    for (const auto& entry : fs::recursive_directory_iterator(source_dir)) {
        const fs::path& source_path = entry.path();
        // 构建目标路径：通过相对路径拼接
        fs::path relative_path = fs::relative(source_path, source_dir);
        fs::path target_path = target_dir / relative_path;

        std::error_code ec; // 用于非抛出异常的函数调用

        if (fs::is_directory(entry.status())) {
            // 如果是目录，确保目标目录也存在
            if (!fs::exists(target_path, ec)) {
                fs::create_directory(target_path, ec);
                if (ec) {
                    std::cerr << "创建目录失败: " << target_path << " - " << ec.message() << std::endl;
                } else {
                    std::cout << "  创建目录: " << target_path << std::endl;
                }
            }
        } else if (fs::is_regular_file(entry.status())) {
            // 如果是普通文件
            bool needs_copy = false;
            if (!fs::exists(target_path, ec)) {
                // 目标文件不存在，需要拷贝
                needs_copy = true;
            } else {
                // 目标文件存在，比较修改时间
                auto source_time = get_last_write_time(source_path);
                auto target_time = get_last_write_time(target_path);

                if (source_time > target_time) {
                    // 源文件比目标文件新，需要更新
                    needs_copy = true;
                }
                // 也可以比较文件大小，但时间通常更可靠
                // if (fs::file_size(source_path, ec) != fs::file_size(target_path, ec)) {
                //     needs_copy = true;
                // }
            }

            if (needs_copy) {
                fs::copy_file(source_path, target_path, fs::copy_options::overwrite_existing, ec);
                if (ec) {
                    std::cerr << "  拷贝文件失败: " << source_path << " 到 " << target_path << " - " << ec.message() << std::endl;
                } else {
                    std::cout << "  拷贝/更新文件: " << source_path.filename() << std::endl;
                }
            } else {
                // std::cout << "  文件已是最新: " << source_path.filename() << std::endl;
            }
        }
        // 对于其他类型，如符号链接，这里暂时忽略或根据需求添加逻辑
    }
    std::cout << "同步完成。" << std::endl;
}

// int main() {
//     fs::path src = "source_data";
//     fs::path dst = "target_backup";

//     // 准备一些测试数据
//     fs::create_directories(src / "subdir1");
//     std::ofstream(src / "file1.txt") << "content1";
//     std::ofstream(src / "subdir1" / "file2.txt") << "content2";

//     sync_directories(src, dst);

//     // 模拟源文件更新
//     std::cout << "\n模拟源文件更新...\n";
//     std::ofstream(src / "file1.txt") << "new content for file1";
//     std::ofstream(src / "new_file.txt") << "this is a new file";

//     sync_directories(src, dst);

//     // 清理
//     // fs::remove_all(src);
//     // fs::remove_all(dst);
//     return 0;
// }