path-Klasse

Die path Klasse speichert ein Objekt vom Typ string_type, das hier für die Zwecke der Exposition aufgerufen myname wird, geeignet für die Verwendung als Pfadname. string_type ist ein Synonym für basic_string<value_type>, bei dem value_type es sich um ein Synonym für wchar_t Windows oder char posIX handelt.

Die path hier beschriebene Klasse ist die C++17-Klasse std::filesystem::path im <filesystem> Header.

Weitere Informationen und Codebeispiele finden Sie unter "Dateisystemnavigation (C++)".

Syntax

class path;

Konstruktoren

TypeDefs

Enumerations

Memberfunktionen

Operatoren

Anforderungen

Kopfball:<filesystem>

Namespace:std::filesystem

path::append

Fügt die angegebene Sequenz nach Bedarf anmyname, konvertiert und eingefügt.preferred_separator

template <class Source>
path& append(const Source& source);

template <class InIt>
path& append(InIt first, InIt last);

Parameter

source
Angegebene Sequenz.

first
Beginn der angegebenen Sequenz.

last
Ende der angegebenen Sequenz.

path::assign

myname Ersetzt nach Bedarf durch die angegebene Sequenz.

path& assign(string_type&& source);

template <class Source>
path& assign(const Source& source);

template <class InIt>
path& assign(InIt first, InIt last);

Parameter

source
Angegebene Sequenz.

first
Beginn der angegebenen Sequenz.

last
Ende der angegebenen Sequenz.

path::begin

Gibt ein path::iterator Designieren des ersten Pfadelements im Pfadnamen zurück, sofern vorhanden.

iterator begin() const;

path::c_str

Gibt einen Zeiger auf das erste Zeichen in myname.

const value_type* c_str() const noexcept;

path::clear

Führt aus myname.clear().

void clear() noexcept;

path::compare

Die erste Funktion vergleicht die Elemente dieses Pfads mit pval. Die anderen Funktionen erstellen einen Pfad aus ihrem Argument und geben das Ergebnis des Vergleichs mit diesem Pfad zurück.

int compare(const path& pval) const noexcept;
int compare(const string_type& str) const;
int compare(basic_string_view<value_type> str) const;
int compare(const value_type *ptr) const;

Parameter

pval
Der zu vergleichende Pfad.

str
Zu vergleichende Zeichenfolge.

ptr
Zu vergleichende Zeiger.

path::concat

Fügt die angegebene Sequenz nach Bedarf an myname, konvertiert (aber kein Trennzeichen einfügen).

template <class Source>
path& concat(const Source& source);

template <class InIt>
path& concat(InIt first, InIt last);

Parameter

source
Angegebene Sequenz.

first
Beginn der angegebenen Sequenz.

last
Ende der angegebenen Sequenz.

path::const_iterator

Ein Synonym für iterator.

typedef iterator const_iterator;

path::empty

Gibt myname.empty() zurück.

bool empty() const noexcept;

path::end

Gibt einen End-of-Sequence-Iterator vom Typ iteratorzurück.

iterator end() const;

path::extension

Gibt das Suffix von filename().

path extension() const;

Hinweise

Gibt das Suffix der filename() X folgenden Art zurück:

Wenn X == path(".") || X == path("..") oder wenn X kein Punkt enthalten ist, ist das Suffix leer.

Andernfalls beginnt das Suffix mit dem rechten Punkt (und umfasst diesen).

path::filename

Gibt die Dateinamenkomponente von myname, insbesondere empty() ? path() : *--end(). Die Komponente kann leer sein.

path filename() const;

path::format

Gibt das Pfadnamenformat an, das zum Interpretieren der an einen path Konstruktor übergebenen Zeichensequenz verwendet wird.

enum format {
    auto_format,
    native_format,
    generic_format
};

Mitglieder

Hinweise

Da das systemeigene Format und das generische Format in Windows austauschbar sind, behandelt die Microsoft Implementierung alle drei Enumerationen gleich. Der format Parameter wird für die Standardkonformität und Portabilität bereitgestellt. Weitere Informationen finden Sie in der Spezifikation WG21 N4659 [fs.class.path].

path::generic_string

Gibt this->string<Elem, Traits, Alloc>(al) zurück, wobei jeder umgekehrte Schrägstrich in einen Schrägstrich konvertiert wird (unter Windows).

template <class Elem,
    class Traits = char_traits<Elem>,
    class Alloc = allocator<Elem>>
  basic_string<Elem, Traits, Alloc>
    generic_string(const Alloc& al = Alloc()) const;

string generic_string() const;

path::generic_u16string

Gibt u16string() zurück, wobei jeder umgekehrte Schrägstrich in einen Schrägstrich konvertiert wird (unter Windows).

u16string generic_u16string() const;

path::generic_u32string

Gibt u32string() zurück, wobei jeder umgekehrte Schrägstrich in einen Schrägstrich konvertiert wird (unter Windows).

u32string generic_u32string() const;

path::generic_u8string

Gibt u8string() zurück, wobei jeder umgekehrte Schrägstrich in einen Schrägstrich konvertiert wird (unter Windows).

string generic_u8string() const;

path::generic_wstring

Gibt wstring() zurück, wobei jeder umgekehrte Schrägstrich in einen Schrägstrich konvertiert wird (unter Windows).

wstring generic_wstring() const;

path::has_extension

Gibt !extension().empty() zurück.

bool has_extension() const;

path::has_filename

Gibt !filename().empty() zurück.

bool has_filename() const;

path::has_parent_path

Gibt !parent_path().empty() zurück.

bool has_parent_path() const;

path::has_relative_path

Gibt !relative_path().empty() zurück.

bool has_relative_path() const;

path::has_root_directory

Gibt !root_directory().empty() zurück.

bool has_root_directory() const;

path::has_root_name

Gibt !root_name().empty() zurück.

bool has_root_name() const;

path::has_root_path

Gibt !root_path().empty() zurück.

bool has_root_path() const;

path::has_stem

Gibt !stem().empty() zurück.

bool has_stem() const;

path::is_absolute

Für Windows gibt die Funktion zurück has_root_name() && has_root_directory(). Für POSIX gibt die Funktion zurück has_root_directory().

bool is_absolute() const;

path::is_relative

Gibt !is_absolute() zurück.

bool is_relative() const;

path::iterator

Ein bidirektionaler Konstanten-Iterator, der die Pfadkomponenten von myname.

class iterator
   {
   // bidirectional iterator for path
   typedef bidirectional_iterator_tag iterator_category;
   typedef path_type value_type;
   typedef ptrdiff_t difference_type;
   typedef const value_type *pointer;
   typedef const value_type& reference;
   // ...
   };

Hinweise

Die Klasse beschreibt einen bidirektionalen Konstanten-Iterator, der die path Komponenten myname der Sequenz angibt:

1. den Stammnamen, falls vorhanden

2. das Stammverzeichnis, falls vorhanden

3. die verbleibenden Verzeichniselemente des übergeordneten pathElements , falls vorhanden, mit dem Dateinamen enden, sofern vorhanden

Für pval ein Objekt vom Typ path:

1. path::iterator X = pval.begin() legt das erste path Element im Pfadnamen fest, falls vorhanden.

2. X == pval.end() ist true , wenn X Punkte direkt hinter dem Ende der Sequenz von Komponenten liegt.

3. *X gibt eine Zeichenfolge zurück, die der aktuellen Komponente entspricht.

4. ++X legt die nächste Komponente in der Sequenz fest, falls vorhanden.

5. --X legt die vorhergehende Komponente in der Sequenz fest, falls vorhanden.

6. myname Durch das Ändern werden alle Iteratoren, die Elemente entwerfen, ungültig.myname

path::lexically_normal

Gibt myname konvertiert in normales Formular zurück. Die Konvertierung ist rein lexikalisch: Auf das Dateisystem wird nicht zugegriffen.

path lexically_normal() const;

Hinweise

Die Normalisierung reduziert redundante Elemente wie . und .. Verzeichnistrennzeichen. Beispielsweise path("a/./b/../c").lexically_normal() ergibt sich a\c Windows. Ein leerer Pfad normalisiert sich auf einen leeren Pfad; ein Pfad, der auf nichts normalisiert.. Die vollständige Normalisierungsalgorithmus finden Sie in der Spezifikation WG21 N4659 [fs.path.generic]..

path::lexically_proximate

Gibt das Ergebnis von lexically_relative(base). Wenn das Ergebnis ein leerer Pfad ist, wird stattdessen eine Kopie *this zurückgegeben.

path lexically_proximate(const path& base) const;

Parameter

base
Der Basispfad, an den sie sich annähern lassen.*this

path::lexically_relative

Gibt relativ myname zu baseeiner lexikalischen (Zeichenfolgen)-Analyse zurück. Auf das Dateisystem wird nicht zugegriffen.

path lexically_relative(const path& base) const;

Parameter

base
Der Basispfad, zu dem relativ zu machen *this ist.

Hinweise

Wenn root_name() != base.root_name()oder wenn ein Pfad absolut und der andere relativ ist oder wenn der Pfad einen Dateinamen, aber kein Stammverzeichnis aufweist, während die Basis nicht, einen leeren Pfad zurückgibt. Bestimmt andernfalls den relativen Pfad von zu dem*this, indem das erste nicht übereinstimmende Element ermittelt und .. für jedes verbleibende Element basevon , gefolgt von den verbleibenden Elementen von *this.base path("/a/d").lexically_relative("/a/b/c") ergibt beispielsweise ..\..\d. Den vollständigen Algorithmus finden Sie in der Spezifikation WG21 N4659 [fs.path.gen].

path::make_preferred

Wandelt jedes Trennzeichen nach Bedarf in ein preferred_separator .

path& make_preferred();

path::native

Rufen Sie die native Zeichenfolgendarstellung des Pfads ab.

const string_type& native() const noexcept;

Hinweise

Der Pfad ist in einem portablen generischen Format (siehe generic_string()) oder dem systemeigenen Format des Pfads verfügbar. Diese Funktion gibt die systemeigene Zeichenfolge zurück. Auf einem POSIX-System sind das generische Format und das systemeigene Format identisch.

Im folgenden Beispiel, das auf Windows ausgeführt wird, ist c:/t/temp.txt die generische Pfadzeichenfolge und die systemeigene Zeichenfolge .c:\t\temp.txt

// Compile with /std:c++17 or higher
#include <filesystem>

int main()
{
    std::filesystem::path p(R"(c:\t\temp.txt)");
    auto native = p.native();          // Windows: L"c:\\t\\temp.txt"
    auto generic = p.generic_string(); // Windows: "c:/t/temp.txt"
}

path::operator=

Ersetzt die Elemente des Pfads durch eine Kopie eines anderen Pfads.

path& operator=(const path& right);
path& operator=(path&& right) noexcept;
path& operator=(string_type&& source);

template <class Source>
path& operator=(const Source& source);

Parameter

right
Das path kopierte In das path.

source
Der Quell-path.

Hinweise

Der erste Memberoperator kopiert right.myname in myname. Der zweite Memberoperator wechselt right.myname zu myname. Der dritte Memberoperator wechselt source in myname. Der vierte Memberoperator verhält sich wie *this = path(source).

path::operator+=

Verschiedene concat Ausdrücke.

path& operator+=(const path& right);
path& operator+=(const string_type& str);
path& operator+=(basic_string_view<value_type> str);
path& operator+=(const value_type *ptr);
path& operator+=(value_type elem);

template <class Source>
path& operator+=(const Source& source);

template <class Elem>
path& operator+=(Elem elem);

Parameter

right
Der hinzugefügte Pfad.

str
Die hinzugefügte Zeichenfolge.

ptr
Der hinzugefügte Zeiger.

elem
Das hinzugefügte value_type oder Elem.

source
Die hinzugefügte Quelle.

Hinweise

Die Memberfunktionen verhalten sich genauso wie das Aufrufen concat mit dem Argument. Die pathÜberladungen , string_type, basic_string_view, und NULL-beendete value_type* Überladungen verketten die Zeichensequenz des Arguments. Die value_type Überladungen Elem verketten ein einzelnes Zeichen. Die vorlagenbasierte Source Überladung verkettet die konvertierte Quellsequenz.

path::operator/=

Verschiedene append Ausdrücke.

path& operator/=(const path& right);

template <class Source>
path& operator/=(const Source& source);

Parameter

right
Der hinzugefügte Pfad.

source
Die hinzugefügte Quelle.

Hinweise

Die Memberfunktionen verhalten sich wie die folgenden entsprechenden Ausdrücke:

1. append(right);

2. append(source);

path::operator string_type

Gibt myname zurück.

operator string_type() const;

path::parent_path

Gibt die übergeordnete Pfadkomponente von myname.

path parent_path() const;

Hinweise

Gibt die übergeordnete Pfadkomponente von myname, insbesondere das Präfix nach myname dem Entfernen filename().native() und alle unmittelbar vorangehenden Verzeichnistrennzeichen zurück. (Gleich, wenn begin() != end(), ist es die Kombination aller Elemente im Bereich [begin(), --end()) durch aufeinander folgende Anwendung operator/=.) Die Komponente ist möglicherweise leer.

path::path

Erstellt eine path auf verschiedene Weise.

path() noexcept;

path(const path& right);
path(path&& right) noexcept;

path(string_type&& source, format fmt = auto_format);

template <class Source>
path(const Source& source, format fmt = auto_format);

template <class InIt>
path(InIt first, InIt last, format fmt = auto_format);

template <class Source>
path(const Source& source, const locale& loc, format fmt = auto_format);

template <class InIt>
path(InIt first, InIt last, const locale& loc, format fmt = auto_format);

Parameter

right
Der Pfad, von dem der konstruierte Pfad eine Kopie sein soll.

source
Die Quelle, von der der konstruierte Pfad eine Kopie sein soll.

fmt
Der Pfadname format , der zum Interpretieren oder Zum Interpretieren source des Bereichs first/last verwendet wird. Wird standardmäßig auf auto_format festgelegt.

loc
Das angegebene Gebietsschema.

first
Die Position des ersten zu kopierenden Elements.

last
Die Position des letzten zu kopierenden Elements.

Hinweise

Die Konstruktoren erstellen myname alle auf verschiedene Arten:

Dafür path() ist myname()es .

Dafür path(const path& right) ist myname(right.myname)es .

Dafür path(path&& right) ist myname(right.myname)es .

Dafür path(string_type&& source, format fmt) ist myname(move(source))es .

Dafür template<class Source> path(const Source& source, format fmt) ist myname(source)es .

Für template<class Source> path(const Source& source, const locale& loc, format fmt) sie myname(source)erhalten Sie alle erforderlichen codecvt Facets von loc.

Dafür template<class InIt> path(InIt first, InIt last, format fmt) ist myname(first, last)es .

Für template<class InIt> path(InIt first, InIt last, const locale& loc, format fmt) sie myname(first, last)erhalten Sie alle erforderlichen codecvt Facets von loc.

Der fmt Parameter wählt das Pfadnamenformat aus. Bei Windows sind die systemeigenen und generischen Formate austauschbar, sodass die Microsoft Implementierung ignoriert fmtwird.

path::preferred_separator

Das konstante Objekt gibt je nach Betriebssystem des Hosts das bevorzugte Zeichen zum Trennen von Pfadkomponenten zurück.

#if _WIN32_C_LIB
static constexpr value_type preferred_separator = L'\\';
#else // assume POSIX
static constexpr value_type preferred_separator = '/';
#endif // filesystem model now defined

Hinweise

In den meisten Kontexten unter Windows ist die Verwendung L'/' in den meisten Kontexten gleichermaßen zulässig.

path::relative_path

Gibt die relative Pfadkomponente von myname.

path relative_path() const;

Hinweise

Gibt die relative Pfadkomponente von myname, insbesondere das Suffix nach myname dem Entfernen root_path().native() und alle unmittelbar nachfolgenden redundanten Verzeichnistrennzeichen zurück. Die Komponente kann leer sein.

path::remove_filename

Entfernt den Dateinamen.

path& remove_filename();

path::replace_extension

Ersetzt die Erweiterung von myname.

path& replace_extension(const path& newext = path());

Parameter

newext
Die neue Erweiterung.

Hinweise

Entfernt zuerst das Suffix extension().native() aus myname. Wenn es sich dann !newext.empty() && newext[0] != dot um einen Punkt handelt *path(".").c_str(), wird der Punkt angefügtmyname. newext Anschließend wird an .myname

path::replace_filename

Ersetzt den Dateinamen.

path& replace_filename(const path& pval);

Parameter

pval
Der Pfad des Dateinamens.

Hinweise

Die Memberfunktion führt Folgendes aus:

remove_filename();

*this /= pval;
return (*this);

path::root_directory

Gibt die Stammverzeichniskomponente von myname.

path root_directory() const;

Hinweise

Die Komponente kann leer sein.

path::root_name

Gibt die Stammnamenkomponente von myname.

path root_name() const;

Hinweise

Die Komponente kann leer sein.

path::root_path

Gibt die Stammpfadkomponente von myname.

path root_path() const;

Hinweise

Gibt die Stammpfadkomponente von myname, insbesondere root_name() / root_directory. Die Komponente kann leer sein.

path::stem

Gibt die stem Komponente von myname.

path stem() const;

Hinweise

Gibt die stem Komponente von myname, insbesondere filename().native() bei entfernten nachgestellten extension().native() . Die Komponente kann leer sein.

path::string

Konvertiert die in myname.

template <class Elem, class Traits = char_traits<Elem>, class Alloc = allocator<Elem>>
basic_string<Elem, Traits, Alloc> string(const Alloc& al = Alloc()) const;
string string() const;

Hinweise

Die erste Memberfunktion (Vorlage) konvertiert die sequenz, die auf die gleiche Weise gespeichert myname ist wie:

1. string() für string<char, Traits, Alloc>()

2. wstring() für string<wchar_t, Traits, Alloc>()

3. u16string() für string<char16_t, Traits, Alloc>()

4. u32string() für string<char32_t, Traits, Alloc>()

Die zweite Memberfunktion konvertiert die sequenz, die in myname der vom Hostsystem bevorzugten Codierung für eine char Sequenz gespeichert ist, und gibt sie in einem Objekt vom Typ stringzurück.

path::string_type

Der Typ ist ein Synonym für basic_string<value_type>.

typedef basic_string<value_type> string_type;

path::swap

Führt aus swap(myname, right.myname).

void swap(path& right) noexcept;

path::u16string

Konvertiert die in myname UTF-16 gespeicherte Sequenz und gibt sie in einem Objekt vom Typ u16stringzurück.

u16string u16string() const;

path::u32string

Konvertiert die in myname UTF-32 gespeicherte Sequenz und gibt sie in einem Objekt vom Typ u32stringzurück.

u32string u32string() const;

path::u8string

Konvertiert die in myname UTF-8 gespeicherte Sequenz und gibt sie in einem Objekt vom Typ u8stringzurück.

string u8string() const;

path::value_type

Der Typ beschreibt die path vom Hostbetriebssystem bevorzugten Elemente.

#if _WIN32_C_LIB
typedef wchar_t value_type;
#else // assume POSIX
typedef char value_type;
#endif // filesystem model now defined

path::wstring

Wandelt die vom Hostsystem bevorzugte Codierung für eine myname Sequenz in wchar_t die Codierung um und gibt sie zurück, die in einem Objekt vom Typ wstringgespeichert ist.

wstring wstring() const;

Siehe auch

<filesystem>
Headerdateienreferenz