Namespaces
Variants

std::filesystem::path:: lexically_normal, std::filesystem::path:: lexically_relative, std::filesystem::path:: lexically_proximate

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
std::filesystem::path
Member types
Member constants
Member functions
Path decomposition
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
Helper classes
path lexically_normal ( ) const ;
(1) (depuis C++17)
path lexically_relative ( const path & base ) const ;
(2) (depuis C++17)
path lexically_proximate ( const path & base ) const ;
(3) (depuis C++17)
1) Renvoie * this converti en forme normale dans son format générique.
2) Retourne * this rendu relatif à base .
  • Premièrement, si root_name ( ) ! = base. root_name ( ) est true ou is_absolute ( ) ! = base. is_absolute ( ) est true ou ( ! has_root_directory ( ) && base. has_root_directory ( ) ) est true ou si un nom de fichier dans relative_path ( ) ou base. relative_path ( ) peut être interprété comme un root-name , retourne un chemin construit par défaut.
  • Sinon, détermine d'abord le premier élément discordant de * this et base comme par auto [ a, b ] = mismatch ( begin ( ) , end ( ) , base. begin ( ) , base. end ( ) ) , puis
  • si a == end ( ) et b == base. end ( ) , retourne path ( "." ) ,
  • sinon, définit N comme le nombre d'éléments de nom de fichier non vides qui ne sont ni dot ni dot-dot dans [ b, base. end ( ) ) , moins le nombre d'éléments de nom de fichier dot-dot . Si N < 0 , retourne un chemin construit par défaut,
  • sinon, si N = 0 et a == end ( ) || a - > empty ( ) , retourne path ( "." ) ,
  • sinon retourne un objet composé de
  • un path ( ) construit par défaut suivi de
  • N applications de operator / = ( path ( ".." ) ) , suivi de
  • une application de operator / = pour chaque élément dans l'intervalle semi-ouvert [ a , end ( ) ) .
3) Si la valeur de lexically_relative ( base ) n'est pas un chemin vide, la retourner. Sinon retourner * this .

Table des matières

Paramètres

(aucun)

Valeur de retour

1) La forme normale du chemin.
2) La forme relative du chemin.
3) La forme proximale du chemin.

Exceptions

Peut lever des exceptions définies par l'implémentation.

Notes

Ces conversions sont purement lexicales. Elles ne vérifient pas que les chemins existent, ne suivent pas les liens symboliques et n'accèdent pas du tout au système de fichiers. Pour les équivalents suivant les liens symboliques de lexically_relative et lexically_proximate , voir relative et proximate .

Sur Windows, le path retourné contient des barres obliques inverses (les séparateurs préférés).

Sur POSIX, aucun nom de fichier dans un chemin relatif n'est acceptable comme root-name .

Exemple

Exécuter ce code 
#include <cassert>
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
int main()
{
    assert(fs::path("a/./b/..").lexically_normal() == "a/");
    assert(fs::path("a/.///b/../").lexically_normal() == "a/");
    assert(fs::path("/a/d").lexically_relative("/a/b/c") == "../../d");
    assert(fs::path("/a/b/c").lexically_relative("/a/d") == "../b/c");
    assert(fs::path("a/b/c").lexically_relative("a") == "b/c");
    assert(fs::path("a/b/c").lexically_relative("a/b/c/x/y") == "../..");
    assert(fs::path("a/b/c").lexically_relative("a/b/c") == ".");
    assert(fs::path("a/b").lexically_relative("c/d") == "../../a/b");
    assert(fs::path("a/b").lexically_relative("/a/b") == "");
    assert(fs::path("a/b").lexically_proximate("/a/b") == "a/b");
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3070 C++17 un nom de fichier pouvant également être un nom racine peut causer un résultat surprenant traité comme cas d'erreur
LWG 3096 C++17 le "/" final et "/." sont gérés incorrectement corrigé

Voir aussi

(C++17)
compose un chemin relatif
(fonction)