CKTIS / C++
Unire i percorsi con `/` in `std::filesystem`
L’operatore `/` restituisce un nuovo percorso senza modificare gli operandi. La sintassi a destra determina se il percorso di sinistra viene esteso o sostituito in tutto o in parte.
Versione: ISO C++23; implementation support may vary
Sintassi
#include <filesystem>
// Friend declaration inside std::filesystem::path (not a member):
friend path operator/(const path& lhs, const path& rhs);
// Typical use, with base of type std::filesystem::path:
base / "guide.txt"In <filesystem>, l’etichetta std::filesystem::operator/ indica un operatore per unire percorsi, non una divisione né una funzione membro. Disponibile da C++17, è una funzione amica non membro nel namespace std::filesystem. Viene trovata tramite la ricerca dipendente dagli argomenti (ADL), non tramite la ricerca qualificata. Scrivi base / "guide.txt" con base di tipo path: il letterale viene convertito in path. Due letterali stringa da soli non funzionano con /.
lhs / rhs applica /= a una copia di lhs e restituisce un path per valore. L’operatore membro /= modifica l’operando sinistro e restituisce un riferimento a esso; += concatena invece il testo del percorso nativo senza inserire un separatore. Se rhs è assoluto o ha un nome di radice diverso da quello di lhs, sostituisce l’intero percorso sinistro. Altrimenti, una directory radice in rhs elimina la directory radice e la parte relativa a sinistra, ma ne conserva il nome di radice. Si aggiunge poi il percorso destro senza il suo nome di radice, con il separatore preferito dove previsto dalle regole. Anche un operando destro vuoto può aggiungere un separatore finale.
L’unione non normalizza il percorso. p.lexically_normal() restituisce un nuovo percorso, eliminando i componenti . superflui e semplificando coppie come drafts/... p.lexically_relative(base) calcola il tragitto da base a p senza prima normalizzarli. Durante i controlli iniziali restituisce un percorso vuoto, per esempio se i nomi di radice sono diversi o se un nome di file nella parte relativa di uno dei due percorsi può essere interpretato come nome di radice. Restituisce . se le sequenze di componenti sono identiche e i percorsi superano quei controlli.
p.is_absolute() verifica se il percorso è assoluto secondo le regole della piattaforma: / da solo è assoluto su POSIX, ma non su Windows. p.empty() verifica se il percorso in formato generico è vuoto, non se una directory è vuota. p.begin() punta al primo componente, non a un carattere o a una voce di directory; per un percorso vuoto restituisce p.end(). Non usare gli iteratori dopo la distruzione di p o dopo aver chiamato su p una funzione membro non const. p.generic_string() restituisce una std::string con separatori /, senza garantire UTF-8.
Queste operazioni trattano la sintassi dei percorsi: non verificano l’esistenza dei file e non risolvono i collegamenti simbolici. L’unione può lanciare un’eccezione, per esempio std::bad_alloc. Né / né lexically_normal() garantiscono che un percorso non attendibile rimanga nella directory scelta: radici, .. o collegamenti simbolici possono invalidare questa ipotesi.
Esempi
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
int main() {
const fs::path base{"docs"};
const fs::path joined = base / "./drafts/../guide.txt";
const fs::path normal = joined.lexically_normal();
const fs::path relative = normal.lexically_relative(base);
std::cout << "base: " << base.generic_string() << '\n'
<< "joined: " << joined.generic_string() << '\n'
<< "normal: " << normal.generic_string() << '\n'
<< "relative: " << relative.generic_string() << '\n'
<< "first: " << normal.begin()->generic_string() << '\n'
<< std::boolalpha
<< "absolute: " << normal.is_absolute() << '\n'
<< "relative.empty(): " << relative.empty() << '\n';
}Risultato
base: docs joined: docs/./drafts/../guide.txt normal: docs/guide.txt relative: guide.txt first: docs absolute: false relative.empty(): false
L’esempio mostra che `base` non cambia. Il percorso unito contiene ancora `.` e `..`; la normalizzazione li elimina. Il tragitto da `docs` al percorso normalizzato è `guide.txt`.
Lezioni correlate
- C++ · Lezione 48 · Avanzato · Versione: 3
Fonti
- C++ working draft: path non-member functions [fs.path.nonmember]
- C++ working draft: hidden friends [hidden.friends]
- C++ working draft: argument-dependent name lookup [basic.lookup.argdep]
- C++ working draft: path appends [fs.path.append]
- C++ working draft: path concatenation [fs.path.concat]
- C++ working draft: path generation [fs.path.gen]
- C++ working draft: path queries [fs.path.query]
- C++ working draft: path iterators [fs.path.itr]
- C++ working draft: generic pathname format [fs.path.generic]
- C++ working draft: filesystem error reporting [fs.err.report]
- cppreference: std::filesystem::operator/(std::filesystem::path)
- cppreference: std::filesystem::path::generic_string and related observers