CKTIS / C++
Joindre des chemins avec `/` dans `std::filesystem`
L’opérateur `/` renvoie un nouveau chemin sans modifier ses opérandes. La syntaxe du chemin de droite détermine s’il s’ajoute au chemin de gauche ou en remplace tout ou partie.
Version : ISO C++23; implementation support may vary
Syntaxe
#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"Dans <filesystem>, l’étiquette std::filesystem::operator/ désigne un opérateur de jointure de chemins, et non une division ni une fonction membre. Disponible depuis C++17, c’est une fonction amie non membre de l’espace de noms std::filesystem, trouvée par la recherche dépendante des arguments (ADL), pas par la recherche qualifiée. Écrivez base / "guide.txt" avec base de type path : le littéral est converti en path. Deux littéraux de chaîne seuls ne fonctionnent pas avec /.
lhs / rhs applique /= à une copie de lhs et renvoie un path par valeur. L’opérateur membre /= modifie l’opérande de gauche et renvoie une référence vers celui-ci. +=, lui, concatène le texte du chemin au format natif sans insérer de séparateur. Si rhs est absolu ou possède un nom de racine différent de celui de lhs, il remplace entièrement le chemin de gauche. Sinon, un répertoire racine dans rhs supprime le répertoire racine et la partie relative de gauche, mais conserve son nom de racine. Le chemin de droite est ensuite ajouté sans son nom de racine, avec le séparateur préféré lorsque les règles le demandent. Même un opérande droit vide peut ajouter un séparateur final.
La jointure ne normalise pas le chemin. p.lexically_normal() renvoie un nouveau chemin en supprimant les composants . superflus et en simplifiant les paires comme drafts/... p.lexically_relative(base) calcule le chemin de base vers p sans les normaliser au préalable. Les vérifications initiales font renvoyer un chemin vide, par exemple si les noms de racine diffèrent ou si un nom de fichier dans la partie relative de l’un des chemins peut être interprété comme un nom de racine. Deux séquences de composants identiques ne donnent . que si les chemins passent ces vérifications.
p.is_absolute() applique les règles de la plateforme : / seul est absolu sous POSIX, mais pas sous Windows. p.empty() teste si le chemin au format générique est vide, pas si un répertoire est vide. p.begin() pointe vers le premier composant, non vers un caractère ou une entrée de répertoire ; pour un chemin vide, il renvoie p.end(). N’utilisez pas les itérateurs après la destruction de p ni après l’appel d’une fonction membre non const sur p. p.generic_string() renvoie une std::string dont les séparateurs sont des /, sans garantie d’encodage UTF-8.
Ces opérations traitent la syntaxe des chemins : elles ne vérifient pas l’existence des fichiers et ne résolvent pas les liens symboliques. La jointure peut lever une exception, par exemple std::bad_alloc. Ni / ni lexically_normal() ne garantit qu’un chemin non fiable reste dans le répertoire choisi : les racines, .. ou les liens symboliques peuvent mettre cette hypothèse en défaut.
Exemples
#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';
}Résultat
base: docs joined: docs/./drafts/../guide.txt normal: docs/guide.txt relative: guide.txt first: docs absolute: false relative.empty(): false
L’exemple montre que `base` reste inchangé. Le chemin obtenu par jointure contient encore `.` et `..` ; la normalisation les supprime. Le chemin de `docs` vers le chemin normalisé est `guide.txt`.
Leçons associées
- C++ · Leçon 48 · Avancé · Version : 3
Sources
- 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