std::filesystem

#include <filesystem>
namespace fs = std::filesystem;  // conventional alias

// Path construction
fs::path p = "/home/user/data.csv";        // from string literal
fs::path p2 = fs::current_path() / "out";  // operator/ concatenates

// Query functions (throw on error)
bool ok   = fs::exists(p);
uintmax_t n = fs::file_size(p);

// Query functions (no-throw)
std::error_code ec;
uintmax_t n2 = fs::file_size(p, ec);  // ec.value() == 0 on success

// Directory iteration
for (const fs::directory_entry& e : fs::directory_iterator(p)) { ... }
for (const fs::directory_entry& e : fs::recursive_directory_iterator(p)) { ... }

// C++17
fs::path base = "/var/log";
fs::path full = base / "app" / "error.log";
// "/var/log/app/error.log"

// Right-hand absolute path replaces the left
fs::path replaced = base / "/etc/hosts";
// "/etc/hosts"  — base is discarded

// Build up incrementally
fs::path p;
p /= "build";
p /= "output";
p /= "main.o";
// "build/output/main.o"

// C++17
fs::path p = "/usr/local/lib/libfoo.so.2";

p.root_name();    // ""        (empty on POSIX; "C:" on Windows)
p.root_directory(); // "/"
p.root_path();    // "/"       (root_name + root_directory)
p.relative_path(); // "usr/local/lib/libfoo.so.2"
p.parent_path();  // "/usr/local/lib"
p.filename();     // "libfoo.so.2"
p.stem();         // "libfoo.so"   — strips the last extension only
p.extension();    // ".2"

// A deeper stem example
fs::path p2 = "archive.tar.gz";
p2.stem();      // "archive.tar"  — only last extension stripped
p2.extension(); // ".gz"

// C++17
fs::path p = "/home/user/report.txt";

// Replace extension
p.replace_extension(".bak");
// "/home/user/report.bak"

p.replace_extension("");     // remove extension entirely
// "/home/user/report"

// Replace filename
p.replace_filename("summary.pdf");
// "/home/user/summary.pdf"

// Remove filename (equivalent to parent_path())
p.remove_filename();
// "/home/user/"

// C++17
fs::path messy = "/var/./log/../log/app//";
fs::path clean = messy.lexically_normal();
// "/var/log/app"

// Relative normalisation
fs::path rel = "a/b/../../c/./d";
rel.lexically_normal();  // "c/d"

// Make relative to a base (no stat — purely lexical)
fs::path full  = "/usr/local/lib/pkgconfig";
fs::path base2 = "/usr/local";
full.lexically_relative(base2);  // "lib/pkgconfig"

// C++17
fs::path p = "/home/user/data.csv";

p.string();          // native encoding (char on POSIX, narrow on Windows)
p.wstring();         // wchar_t string (useful on Windows)
p.u8string();        // UTF-8 encoded — std::string in C++17, std::u8string in C++20
p.u16string();       // UTF-16
p.u32string();       // UTF-32
p.generic_string();  // forward slashes on ALL platforms — use for logging/display
p.generic_u8string(); // forward slashes + UTF-8

// On Windows:
// p.string()          might be "C:\\Users\\user\\data.csv"
// p.generic_string()  gives   "C:/Users/user/data.csv"

// C++17

// --- Throwing version ---
// Use when failure is unexpected (programmer error, corrupted state)
try {
    fs::remove("/tmp/scratch.dat");
} catch (const fs::filesystem_error& e) {
    // e.what()   — human-readable description
    // e.path1()  — first path involved
    // e.path2()  — second path (for two-argument operations like copy/rename)
    // e.code()   — the std::error_code
    std::cerr << "Unexpected error: " << e.what() << '\n';
    throw;
}

// --- Non-throwing version ---
// Use when failure is expected (file may not exist, permission may be denied)
std::error_code ec;
fs::remove("/tmp/scratch.dat", ec);
if (ec) {
    if (ec == std::errc::no_such_file_or_directory) {
        // file was already gone — that's fine
    } else {
        std::cerr << "remove failed: " << ec.message() << '\n';
    }
}

// C++17
std::error_code ec;
fs::file_size("missing.txt", ec);

if (ec == std::errc::no_such_file_or_directory) { /* ENOENT */ }
if (ec == std::errc::permission_denied)         { /* EACCES */ }
if (ec == std::errc::not_a_directory)           { /* ENOTDIR */ }

// C++17
fs::path dir = "src";

for (const fs::directory_entry& entry : fs::directory_iterator(dir)) {
    if (entry.is_regular_file()) {
        std::cout << "  file: " << entry.path().filename().string() << '\n';
    } else if (entry.is_directory()) {
        std::cout << "  dir:  " << entry.path().filename().string() << '\n';
    } else if (entry.is_symlink()) {
        std::cout << "  link: " << entry.path().filename().string() << '\n';
    }
}

// C++17
for (const fs::directory_entry& entry :
        fs::recursive_directory_iterator("project")) {
    // entry.depth() — 0 for direct children of "project"
    std::string indent(entry.depth() * 2, ' ');
    std::cout << indent << entry.path().filename().string() << '\n';
}

// C++17 — collect all .cpp files under a directory tree
std::vector<fs::path> sources;

std::error_code ec;
fs::recursive_directory_iterator it("src", ec);
fs::recursive_directory_iterator end;

for (; it != end; it.increment(ec)) {
    if (ec) { ec.clear(); continue; }  // skip unreadable dirs
    const fs::directory_entry& entry = *it;
    if (entry.is_regular_file() && entry.path().extension() == ".cpp") {
        sources.push_back(entry.path());
    }
}

// C++17
for (const auto& e : fs::recursive_directory_iterator(
        "src", fs::directory_options::skip_permission_denied)) {
    if (e.is_regular_file() && e.path().extension() == ".cpp") {
        sources.push_back(e.path());
    }
}

// C++17

// Copy a single file (throws if dst exists)
fs::copy("src/main.cpp", "backup/main.cpp");

// Overwrite if destination already exists
fs::copy("src/main.cpp", "backup/main.cpp",
         fs::copy_options::overwrite_existing);

// Skip if destination is already up-to-date (based on mtime)
fs::copy("src/main.cpp", "backup/main.cpp",
         fs::copy_options::update_existing);

// Skip without error if destination exists
fs::copy("src/main.cpp", "backup/main.cpp",
         fs::copy_options::skip_existing);

// Recursive directory copy
fs::copy("build/artifacts", "deploy/",
         fs::copy_options::overwrite_existing | fs::copy_options::recursive);

// Copy symlinks as symlinks (default would follow and copy target)
fs::copy("link_to_file", "link_copy",
         fs::copy_options::copy_symlinks);

// Non-throwing form
std::error_code ec;
fs::copy("src", "dst", fs::copy_options::recursive, ec);
if (ec) { std::cerr << "copy: " << ec.message() << '\n'; }

// C++17
fs::rename("old_name.txt", "new_name.txt");   // same dir — atomic on POSIX

// Safe write-then-rename pattern
fs::path target = "config.json";
fs::path tmp    = target;
tmp += ".tmp";

{
    std::ofstream out(tmp);
    out << new_content;
}  // flush + close before rename

fs::rename(tmp, target);  // atomic swap on POSIX

// C++17
bool was_present = fs::remove("scratch.dat");    // false if already absent
// fs::remove on a non-empty directory throws — use remove_all

std::uintmax_t count = fs::remove_all("build/");  // recursive, returns entry count
// returns (uintmax_t)-1 on error (C++17); use error_code overload to check

std::error_code ec;
fs::remove_all("build/", ec);
if (ec) { std::cerr << "remove_all: " << ec.message() << '\n'; }

// C++17
fs::create_directory("logs");           // creates one directory; fails if parent absent
fs::create_directories("logs/2026/06"); // creates entire chain — no error if already exists

// Check the return value: false means dir already existed (not an error)
bool created = fs::create_directories("out/reports");

// C++17
fs::path p = "data.bin";

bool exists  = fs::exists(p);            // follows symlinks
uintmax_t sz = fs::file_size(p);         // throws if p is a directory or absent

fs::file_time_type mtime = fs::last_write_time(p);

// Convert to wall clock (C++20 provides clock_cast)
auto sys = std::chrono::clock_cast<std::chrono::system_clock>(mtime);  // C++20
std::time_t t = std::chrono::system_clock::to_time_t(sys);

// C++17
fs::file_status st = fs::status("report.pdf");

// File type
st.type() == fs::file_type::regular;
st.type() == fs::file_type::directory;
st.type() == fs::file_type::symlink;  // only via symlink_status()
st.type() == fs::file_type::not_found;

// Convenience predicates (same as calling fs::is_regular_file etc. with status)
fs::is_regular_file(st);
fs::is_directory(st);

// Permission bits
fs::perms perms = st.permissions();
bool readable = (perms & fs::perms::owner_read) != fs::perms::none;

// C++17

// Read current permissions
fs::file_status st = fs::status("secret.key");
fs::perms p = st.permissions();

bool owner_r = (p & fs::perms::owner_read)  != fs::perms::none;
bool owner_w = (p & fs::perms::owner_write) != fs::perms::none;
bool owner_x = (p & fs::perms::owner_exec)  != fs::perms::none;

// --- Replace: set exact bits ---
fs::permissions("secret.key",
    fs::perms::owner_read | fs::perms::owner_write,
    fs::perm_options::replace);   // equivalent to chmod 600

// --- Add: add execute bit without touching others ---
fs::permissions("script.sh",
    fs::perms::owner_exec | fs::perms::group_exec | fs::perms::others_exec,
    fs::perm_options::add);       // equivalent to chmod +x

// --- Remove: strip all write bits (make read-only) ---
fs::permissions("readme.txt",
    fs::perms::owner_write | fs::perms::group_write | fs::perms::others_write,
    fs::perm_options::remove);    // equivalent to chmod a-w

// --- Non-throwing form ---
std::error_code ec;
fs::permissions("log.txt", fs::perms::owner_read, fs::perm_options::replace, ec);
if (ec) { std::cerr << "chmod: " << ec.message() << '\n'; }

// C++17 — a simple (non-atomic) temp path
fs::path tmp_dir  = fs::temp_directory_path();
fs::path tmp_file = tmp_dir / ("myapp_" + std::to_string(std::time(nullptr)) + ".tmp");

// WARNING: another process could create the same name between this line
// and when you open it. Fine for low-contention single-process tools;
// not safe for security-sensitive code.
std::ofstream out(tmp_file);

// POSIX fallback — C++17 has no mkstemp equivalent
#include <cstdlib>   // mkstemp
#include <unistd.h>  // close, write

fs::path make_temp_file() {
    fs::path tmpl = fs::temp_directory_path() / "myapp_XXXXXX";
    std::string s = tmpl.string();
    int fd = ::mkstemp(s.data());  // modifies s in-place, creates and opens atomically
    if (fd == -1) throw std::system_error(errno, std::system_category(), "mkstemp");
    ::close(fd);  // close the fd; caller opens via fs::path
    return fs::path(s);
}

// C++17 — RAII temp-file guard
struct TempFile {
    fs::path path;
    explicit TempFile(fs::path p) : path(std::move(p)) {}
    ~TempFile() { std::error_code ec; fs::remove(path, ec); /* ignore error */ }
    TempFile(const TempFile&) = delete;
    TempFile& operator=(const TempFile&) = delete;
};

// C++17

// On Windows, if the path contains non-ASCII characters (e.g. Chinese, Arabic,
// Russian filenames), path.string() encodes in the *current ANSI code page*.
// If the code page does not cover those characters, they are replaced with '?'.

fs::path p = fs::u8path(u8"/home/用户/文件.txt");  // construct from UTF-8

std::string narrow = p.string();    // DANGER on Windows: may lose information
std::string utf8   = p.u8string();  // SAFE: always UTF-8, preserves all characters

// On POSIX, path.string() returns the raw bytes — which is usually UTF-8 on
// modern systems, but depends on the locale. u8string() reinterprets those bytes
// as UTF-8 (no conversion), so it is safe on UTF-8 locales.

// C++17 — constructing a path from UTF-8 source text
std::string utf8_input = get_user_input();  // UTF-8 string from UI

#if defined(_WIN32)
    // fs::u8path converts UTF-8 → wchar_t internally on Windows
    fs::path p = fs::u8path(utf8_input);
#else
    fs::path p(utf8_input);  // POSIX: char is already the native type
#endif

// Or portably:
fs::path p2 = fs::u8path(utf8_input);  // correct on all platforms in C++17
// Note: fs::u8path is deprecated in C++20; use fs::path(u8"...") with u8 literals

std::error_code ec;
for (const fs::directory_entry& e :
        fs::recursive_directory_iterator("src", ec)) {
    if (ec) { /* permission denied on some subdir — continue */ ec.clear(); continue; }

    if (!e.is_regular_file()) continue;  // cached — no syscall
    if (e.path().extension() != ".cpp") continue;

    // file_size() on directory_entry uses cached value on most platforms
    std::println("{:>10} {}", e.file_size(), e.path().string());
}

fs::space_info si = fs::space("/home");  // C++17
std::println("capacity : {} GiB", si.capacity  / (1ULL << 30));
std::println("free     : {} GiB", si.free       / (1ULL << 30));
std::println("available: {} GiB", si.available  / (1ULL << 30));
// available ≤ free — accounts for reserved blocks (root on Linux)

fs::file_time_type mtime = fs::last_write_time("data.bin");  // C++17

// Convert to system_clock (C++20 — clock_cast)
auto sctp = std::chrono::clock_cast<std::chrono::system_clock>(mtime);  // C++20
std::time_t t = std::chrono::system_clock::to_time_t(sctp);
std::println("modified: {}", std::ctime(&t));

// In C++17 only, the conversion is implementation-defined:
// auto sys = decltype(mtime)::clock::to_sys(mtime);  // not portable pre-C++20

for (const auto& e : fs::recursive_directory_iterator(
        root, fs::directory_options::skip_permission_denied)) {
    process(e);
}

// WRONG — another process can delete the file between exists() and open()
if (fs::exists("config.json")) {
    std::ifstream f("config.json");  // may still fail
}

// RIGHT — open unconditionally and handle failure
std::ifstream f("config.json");
if (!f) { /* file absent or unreadable */ }

fs::path link = "current -> /data/v2";
fs::is_directory(link);                          // follows link → true if target is dir
fs::is_symlink(link);                            // false — status() resolves the link
fs::is_symlink(fs::symlink_status(link));        // true

// Correct cross-platform identity check
std::error_code ec;
bool same = fs::equivalent("./foo", "/abs/path/to/foo", ec);