Namespaces
Variants

    std::filesystem::path:: append, std::filesystem::path:: operator/=

    From de.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 & operator / = ( const path & p ) ;
    		(1) (seit C++17)
    template < class Source >
    path & operator / = ( const Source & source ) ;
    		(2) (seit C++17)
    template < class Source >
    path & append ( const Source & source ) ;
    		(3) (seit C++17)
    template < class InputIt >
    path & append ( InputIt first, InputIt last ) ;
    		(4) (seit C++17)
    1) Wenn p. is_absolute ( ) || ( p. has_root_name ( ) && p. root_name ( ) ! = root_name ( ) ) , dann ersetzt den aktuellen Pfad durch p wie durch operator = ( p ) und beendet.
    * Andernfalls, wenn p. has_root_directory ( ) , dann entfernt es jedes Root-Verzeichnis und den gesamten relativen Pfad vom generischen Format-Pfadnamen von * this .
    * Andernfalls, wenn has_filename ( ) || ( ! has_root_directory ( ) && is_absolute ( ) ) , dann fügt path::preferred_separator zum generischen Format von * this hinzu.
    * Auf jeden Fall wird dann der native Format-Pfadname von p , unter Auslassung jeglichen root-name aus seinem generischen Format, an das native Format von * this angehängt. 
    // Wo "//host" ein Root-Name ist
path("//host")  / "foo" // das Ergebnis ist      "//host/foo" (anhängen mit Separator)
path("//host/") / "foo" // das Ergebnis ist auch "//host/foo" (anhängen ohne Separator)
// Unter POSIX,
path("foo") / ""      // das Ergebnis ist "foo/" (anhängt)
path("foo") / "/bar"; // das Ergebnis ist "/bar" (ersetzt)
// Unter Windows,
path("foo") / "C:/bar";  // das Ergebnis ist "C:/bar" (ersetzt)
path("foo") / "C:";      // das Ergebnis ist "C:"     (ersetzt)
path("C:") / "";         // das Ergebnis ist "C:"     (anhängt, ohne Separator)
path("C:foo") / "/bar";  // ergibt "C:/bar"        (entfernt relativen Pfad, dann anhängen)
path("C:foo") / "C:bar"; // ergibt "C:foo/bar"     (anhängen, unter Auslassung von p's Root-Name)
    2,3) Gleich wie (1) , akzeptiert jedoch jeden std::basic_string , std::basic_string_view , nullterminierten Multicharakter-String oder einen Eingabe-Iterator, der auf eine nullterminierte Multicharakter-Sequenz zeigt. Entspricht return operator / = ( path ( source ) ) ; .
    4) Gleich wie (1) , akzeptiert jedoch jedes Iteratorpaar, das eine Mehrzeichenzeichenkette bezeichnet. Entspricht return operator / = ( path ( first, last ) ) ; .

    (2) und (3) nehmen an der Überlagerungsauflösung nur teil, wenn Source und path nicht denselben Typ haben, und entweder:

    Inhaltsverzeichnis

    Parameter

    p - anzuhängender Pfadname
    source - std::basic_string , std::basic_string_view , nullterminierter Multicharakter-String oder ein Eingabeiterator, der auf eine nullterminierte Multicharakter-Sequenz zeigt, die einen Pfadnamen darstellt (entweder im portablen oder im nativen Format)
    first, last - Paar von LegacyInputIterator s , die eine Multicharakter-Sequenz angeben, die einen Pfadnamen darstellt
    Typanforderungen
    -
    InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
    -
    Der Werttyp von InputIt muss einer der kodierten Zeichentypen sein ( char , wchar_t , char16_t und char32_t ).

    Rückgabewert

    * this

    Ausnahmen

    Kann std:: bad_alloc werfen, wenn die Speicherallokation fehlschlägt.

    Hinweise

    Diese Funktionen liefern effektiv eine Annäherung an die Bedeutung des Argumentpfads p in einer Umgebung, in der * this das Startverzeichnis ist.

    Beispiel

    Die Ausgabe wird unter Windows erzeugt.

    Code ausführen 
    #include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
int main()
{
    fs::path p1 = "C:";
    p1 /= "Users"; // does not insert a separator
    std::cout << "\"C:\" / \"Users\" == " << p1 << '\n';
    p1 /= "batman"; // inserts fs::path::preferred_separator, '\' on Windows
    std::cout << "\"C:\" / \"Users\" / \"batman\" == " << p1 << '\n';
}

    Mögliche Ausgabe: 

    "C:" / "Users" == "C:Users"
"C:" / "Users" / "batman" == "C:Users\\batman"

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 3244 C++17 Constraint, dass Source nicht path sein kann, fehlte hinzugefügt

    Siehe auch

    		verkettet zwei Pfade ohne Einführung eines Verzeichnistrennzeichens
    (öffentliche Elementfunktion)
    (C++17)
    		verkettet zwei Pfade mit einem Verzeichnistrennzeichen
    (Funktion)