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) (seit C++17)
path lexically_relative ( const path & base ) const ;
(2) (seit C++17)
path lexically_proximate ( const path & base ) const ;
(3) (seit C++17)
1) Gibt * this konvertiert in Normalform in seinem generischen Format zurück.
2) Gibt * this relativ zu base zurück.
  • Zuerst, falls root_name ( ) ! = base. root_name ( ) true ist oder is_absolute ( ) ! = base. is_absolute ( ) true ist oder ( ! has_root_directory ( ) && base. has_root_directory ( ) ) true ist oder ein Dateiname in relative_path ( ) oder base. relative_path ( ) als root-name interpretiert werden kann, wird ein standardkonstruierter Pfad zurückgegeben.
  • Andernfalls wird zuerst das erste nicht übereinstimmende Element von * this und base bestimmt, als ob durch auto [ a, b ] = mismatch ( begin ( ) , end ( ) , base. begin ( ) , base. end ( ) ) , dann
  • falls a == end ( ) und b == base. end ( ) , wird path ( "." ) zurückgegeben,
  • andernfalls wird N definiert als die Anzahl der nicht-leeren Dateinamenelemente, die weder dot noch dot-dot in [ b, base. end ( ) ) sind, minus der Anzahl der dot-dot Dateinamenelemente. Falls N < 0 , wird ein standardkonstruierter Pfad zurückgegeben,
  • andernfalls, falls N = 0 und a == end ( ) || a - > empty ( ) , wird path ( "." ) zurückgegeben,
  • andernfalls wird ein Objekt zurückgegeben, das zusammengesetzt ist aus
  • einem standardkonstruierten path ( ) , gefolgt von
  • N Anwendungen von operator / = ( path ( ".." ) ) , gefolgt von
  • einer Anwendung von operator / = für jedes Element im halboffenen Bereich [ a , end ( ) ) .
3) Wenn der Wert von lexically_relative ( base ) kein leerer Pfad ist, gib ihn zurück. Andernfalls gib * this zurück.

Inhaltsverzeichnis

Parameter

(keine)

Rückgabewert

1) Die Normalform des Pfades.
2) Die relative Form des Pfades.
3) Die unmittelbare Form des Pfades.

Ausnahmen

Kann implementierungsdefinierte Ausnahmen auslösen.

Hinweise

Diese Konvertierungen sind rein lexikalisch. Sie prüfen nicht, ob die Pfade existieren, folgen keinen symbolischen Links und greifen überhaupt nicht auf das Dateisystem zu. Für die Versionen von lexically_relative und lexically_proximate , die symbolischen Links folgen, siehe relative und proximate .

Unter Windows enthält der zurückgegebene path Backslashes (die bevorzugten Trennzeichen).

Unter POSIX ist kein Dateiname in einem relativen Pfad als root-name zulässig.

Beispiel

Diesen Code ausführen 
#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");
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3070 C++17 Ein Dateiname, der auch ein Root-Name sein kann, kann zu überraschenden Ergebnissen führen Als Fehlerfall behandelt
LWG 3096 C++17 Nachgestelltes "/" und "/." werden falsch behandelt Korrigiert

Siehe auch

(C++17)
Erstellt einen relativen Pfad
(Funktion)