Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::filesystem::path: rappresentazione lessicale di un percorso

std::filesystem::path memorizza sintassi ed elementi di un percorso, ma non verifica da sé esistenza o validità di un oggetto del filesystem.

Versione: C++23

Sintassi

class std::filesystem::path {
public:
    using value_type = /* operating-system-dependent */;
    static constexpr value_type preferred_separator = /* operating-system-dependent */;

    bool empty() const noexcept;
    bool is_absolute() const;
    std::string generic_string() const;
    path lexically_normal() const;
    path lexically_relative(const path& base) const;
    iterator begin() const;
};

path std::filesystem::operator/(const path& lhs, const path& rhs);

std::filesystem::path di <filesystem> rappresenta un root-name opzionale, una root-directory opzionale e una sequenza di nomi. value_type, formato nativo e preferred_separator dipendono dalla piattaforma; generic_string() usa il separatore portabile /.

std::filesystem::path::empty verifica se il pathname è vuoto, mentre std::filesystem::path::is_absolute lo classifica secondo le regole del sistema operativo; nessuna delle due interroga il filesystem. std::filesystem::path::begin avvia l’iterazione sugli elementi e std::filesystem::path::generic_string serializza il formato generico con /. std::filesystem::path::lexically_normal normalizza la sintassi; std::filesystem::path::lexically_relative calcola una forma puramente lessicale rispetto a una base e può restituire un path vuoto per radici o forme assoluta/relativa incompatibili.

La grafia di scope std::filesystem::path::operator/ rappresenta l’obbligo di composizione, ma in C++23 non è un membro: l’interfaccia reale è il non membro std::filesystem::operator/, equivalente a path(lhs) /= rhs. Non va dedotto un alias membro.

L’operatore / compone elementi rispettando regole di radice e separatori, mentre operator+= concatena soltanto caratteri. L’esempio costruisce logs/2026/run.txt e stampa nome file, estensione e genitore logs/2026 in formato generico.

È una classe lessicale: il percorso può non esistere, essere invalido per l’host o risolversi diversamente rispetto alla directory corrente. lexically_normal rimuove componenti sintatticamente e non segue link. operator== confronta rappresentazioni lessicali, non identità dei file; per quest’ultima usa filesystem::equivalent su oggetti esistenti.

Esempi

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;
    const fs::path value = fs::path{"logs"} / "2026" / "run.txt";
    std::cout << value.filename().string() << ' '
              << value.extension().string() << ' '
              << value.parent_path().generic_string() << '\n';
}

Risultato

run.txt .txt logs/2026

std::filesystem::path → run.txt .txt logs/2026

Fonti