`<experimental/filesystem>` Funktionen

Important

Der <experimental/filesystem> Header und der std::experimental::filesystem Namespace haben eine vorab standardmäßige Implementierung der Technischen Spezifikation (File System Technical Specification, TS) bereitgestellt. Diese Dokumentation wird für Code beibehalten, der mit der ursprünglichen Dateisystemimplementierung von MSVC geschrieben wurde, die ab MSVC Version 14.51 entfernt wurde. Verwenden Sie für neuen Code stattdessen den C++17-Header <filesystem> und den std::filesystem Namespace. Informationen zu den Standardentsprechungen dieser Funktionen finden Sie unter <filesystem> "Funktionen".

Diese kostenlosen Funktionen im <experimental/filesystem> Header ändern und abfragen Vorgänge auf Pfaden, Dateien, Symlinks, Verzeichnissen und Volumes. Weitere Informationen und Codebeispiele finden Sie unter Dateisystemnavigation (C++).

Anforderungen

Kopfball:<experimental/filesystem>

Namespace:std::experimental::filesystem

`absolute`

path absolute(const path& pval, const path& base = current_path());

Die Funktion gibt den absoluten Pfadnamen zurück, pval der relativ zum Pfadnamen baseentspricht:

Wenn pval.has_root_name() && pval.has_root_directory() die Funktion zurückgegeben wird pval.
Wenn pval.has_root_name() && !pval.has_root_directory() die Funktion zurückgegeben wirdpval.relative_path()absolute(base).relative_path()absolute(base).root_directory() / pval.root_name() / / .
Wenn !pval.has_root_name() && pval.has_root_directory() die Funktion zurückgegeben wird / absolute(base).root_name()pval.
Wenn !pval.has_root_name() && !pval.has_root_directory() die Funktion zurückgegeben wird / absolute(base)pval.

`begin`

const directory_iterator& begin(const directory_iterator& iter) noexcept;
const recursive_directory_iterator&
    begin(const recursive_directory_iterator& iter) noexcept;

Beide Funktionen geben zurück iter.

`canonical`

path canonical(const path& pval, const path& base = current_path());
path canonical(const path& pval, error_code& ec);
path canonical(const path& pval, const path& base, error_code& ec);

Die Funktionen bilden alle einen absoluten Pfadnamen pabs = absolute(pval, base) (oder pabs = absolute(pval) für die Überladung ohne Basisparameter), und reduzieren Sie ihn dann in der folgenden Schrittfolge auf eine kanonische Form:

Ersetzen Sie jede PfadkomponenteX, für die is_symlink(X) sie verwendet read_symlink(X)wirdtrue.
Entfernen Sie jede Pfadkomponente . (Punkt ist das aktuelle Verzeichnis, das von vorherigen Pfadkomponenten erstellt wurde).
Entfernen Sie jedes Paar von Pfadkomponenten X/.. (dot-dot ist das übergeordnete Verzeichnis, das von vorherigen Pfadkomponenten erstellt wurde).

Die Funktion gibt dann zurück pabs.

`copy`

void copy(const path& from, const path& to);
void copy(const path& from, const path& to, error_code& ec) noexcept;
void copy(const path& from, const path& to, copy_options opts);
void copy(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Die Funktionen können alle möglicherweise eine oder mehrere Dateien kopieren oder verknüpfen, um fromto unter Kontrolle von opts, was für copy_options::none die Überladungen ohne opts Parameter verwendet wird. opts enthält höchstens eine der folgenden:

skip_existing, overwrite_existing oder update_existing
copy_symlinks oder skip_symlinks
directories_only, create_symlinks oder create_hard_links

Die Funktionen bestimmen zunächst die file_status Werte f für from und t für to. Sie werden verwendetsymlink_status, wenn opts sie die Quelle oder das Ziel enthalten copy_options::skip_symlinkscopy_options::create_symlinks, oder copy_options::copy_symlinks, wie für die Quelle oder das Ziel erforderlich. Andernfalls verwenden statussie .

Wenn !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), melden die Funktionen einen Fehler und beenden. Andernfalls, wenn is_symlink(f), dann:

Wenn options & copy_options::skip_symlinks, führen Sie nichts aus.
Andernfalls , wenn !exists(t) && options & copy_options::copy_symlinks, dann copy_symlink(from, to).
Andernfalls melden Sie einen Fehler.

Andernfalls, wenn is_regular_file(f), dann:

Wenn opts & copy_options::directories_only, führen Sie nichts aus.
Andernfalls , wenn opts & copy_options::create_symlinks, dann create_symlink(from, to).
Andernfalls , wenn opts & copy_options::create_hard_links, dann create_hard_link(from, to).
Andernfalls , wenn is_directory(t), dann copy_file(from, to / from.filename(), opts).
Andernfalls, copy_file(from, to, opts).

Andernfalls, wenn is_directory(f) && (opts & copy_options::recursive || !opts), dann:

if (!exists(t))
{  // copy directory contents recursively
    create_directory(to, from, ec);

    for (directory_iterator next(from), end; ec == error_code() && next != end; ++next)
    {
        copy(next->path(), to / next->path().filename(), opts, ec);
    }
}

Andernfalls machen Sie nichts.

`copy_file`

bool copy_file(const path& from, const path& to);
bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
bool copy_file(const path& from, const path& to, copy_options opts);
bool copy_file(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Die Funktionen kopieren die Datei fromto möglicherweise unter Kontrolle von opts, die für copy_options::none die Überladungen ohne opts Parameter verwendet wird. opts enthält höchstens einen von skip_existing, overwrite_existing, oder update_existing.

Wenn exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), dann melden Sie als Fehler, dass die Datei bereits vorhanden ist.

Andernfalls versuchen Sie, !exists(to) || opts & copy_options::overwrite_existing || opts & copy_options::update_existing&& last_write_time(to) < last_write_time(from) || !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing))den Inhalt und die Attribute der Datei in die Datei fromtozu kopieren. Melden Sie sich als Fehler, wenn der Kopierversuch fehlschlägt.

Die Funktionen geben zurück true , wenn die Kopie erfolgreich ist, andernfalls false .

`copy_symlink`

void copy_symlink(const path& from, const path& to);
void copy_symlink(const path& from, const path& to, error_code& ec) noexcept;

Wenn is_directory(from), ruft die Funktion auf create_directory_symlink(from, to). Andernfalls wird es aufgerufen create_symlink(from, to).

`create_directories`

bool create_directories(const path& pval);
bool create_directories(const path& pval, error_code& ec) noexcept;

Für einen Pfadnamen wie a\/b\/cz. B. erstellt die Funktion Verzeichnisse a und a\/b nach Bedarf, damit es das Verzeichnis a\/b\/cerstellen kann. Es wird nur zurückgegeben true , wenn es tatsächlich das Verzeichnis pvalerstellt.

`create_directory`

bool create_directory(const path& pval);

bool create_directory(const path& pval, error_code& ec) noexcept;
bool create_directory(const path& pval, const path& attr);
bool create_directory(const path& pval, const path& attr, error_code& ec) noexcept;

Die Funktion erstellt das Verzeichnis pval nach Bedarf. Es wird nur zurückgegeben true , wenn es tatsächlich das Verzeichnis pvalerstellt. Wenn Sie den attr Parameter angeben, kopiert die Funktion Berechtigungen aus der vorhandenen Datei. Wenn Sie den attr Parameter nicht angeben, verwendet perms::alldie Funktion .

`create_directory_symlink`

void create_directory_symlink(const path& to, const path& link);
void create_directory_symlink(const path& to, const path& link, error_code& ec) noexcept;

Die Funktion erstellt link als Symlink zum Verzeichnis to.

`create_hard_link`

void create_hard_link(const path& to,  const path& link);
void create_hard_link(const path& to, const path& link, error_code& ec) noexcept;

Die Funktion erstellt link eine feste Verknüpfung mit dem Verzeichnis oder der Datei to.

`create_symlink`

void create_symlink(const path& to, const path& link);

void create_symlink(const path& to, const path& link, error_code& ec) noexcept;

Die Funktion erstellt link als Symlink zur Datei to.

`current_path`

path current_path();
path current_path(error_code& ec);
void current_path(const path& pval);
void current_path(const path& pval, error_code& ec) noexcept;

Die Funktionen ohne Parameter pval geben den Pfadnamen für das aktuelle Verzeichnis zurück. Die verbleibenden Funktionen legen das aktuelle Verzeichnis auf pval.

`end`

directory_iterator end(const directory_iterator&) noexcept;
recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;

Die erste Funktion gibt zurück directory_iterator() , und die zweite Funktion gibt zurück recursive_directory_iterator().

`equivalent`

bool equivalent(const path& left, const path& right);
bool equivalent(const path& left, const path& right, error_code& ec) noexcept;

Die Funktionen werden nur zurückgegeben true , wenn links und rechts auf dieselbe Dateisystementität verweisen.

`exists`

bool exists(file_status stat) noexcept;
bool exists(const path& pval);
bool exists(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück status_known(stat) && stat.type() != file_type::not_found. Die zweite und dritte Funktion geben zurück exists(status(pval)).

`file_size`

uintmax_t file_size(const path& pval);
uintmax_t file_size(const path& pval, error_code& ec) noexcept;

Die Funktionen geben die Größe in Byte der ausgewählten pvalDatei zurück, wenn exists(pval) && is_regular_file(pval) und die Dateigröße bestimmt werden kann. Andernfalls melden sie einen Fehler und geben zurück uintmax_t(-1).

`hard_link_count`

uintmax_t hard_link_count(const path& pval);
uintmax_t hard_link_count(const path& pval, error_code& ec) noexcept;

Die Funktion gibt die Anzahl harter Verknüpfungen für pvaloder -1 zurück, wenn ein Fehler auftritt.

`hash_value`

size_t hash_value(const path& pval) noexcept;

Die Funktion gibt einen Hashwert für pval.native().

`is_block_file`

bool is_block_file(file_status stat) noexcept;
bool is_block_file(const path& pval);
bool is_block_file(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::block. Die verbleibenden Funktionen geben zurück is_block_file(status(pval)).

`is_character_file`

bool is_character_file(file_status stat) noexcept;
bool is_character_file(const path& pval);
bool is_character_file(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::character. Die verbleibenden Funktionen geben zurück is_character_file(status(pval)).

`is_directory`

bool is_directory(file_status stat) noexcept;
bool is_directory(const path& pval);
bool is_directory(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::directory. Die verbleibenden Funktionen geben zurück is_directory(status(pval)).

`is_empty`

bool is_empty(const path& pval);
bool is_empty(const path& pval, error_code& ec) noexcept;

Wenn is_directory(pval), gibt die Funktion zurück directory_iterator(pval) == directory_iterator(). Andernfalls wird file_size(pval) == 0zurückgegeben.

`is_fifo`

bool is_fifo(file_status stat) noexcept;
bool is_fifo(const path& pval);
bool is_fifo(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::fifo. Die verbleibenden Funktionen geben zurück is_fifo(status(pval)).

`is_other`

bool is_other(file_status stat) noexcept;
bool is_other(const path& pval);
bool is_other(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück exists(stat) && !is_regular_file(stat) && !is_directory(stat) && !is_symlink(stat). Die verbleibenden Funktionen geben zurück is_other(status(pval)).

`is_regular_file`

bool is_regular_file(file_status stat) noexcept;
bool is_regular_file(const path& pval);
bool is_regular_file(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::regular. Die verbleibenden Funktionen geben zurück is_regular_file(status(pval)).

`is_socket`

bool is_socket(file_status stat) noexcept;
bool is_socket(const path& pval);
bool is_socket(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::socket. Die verbleibenden Funktionen geben zurück is_socket(status(pval)).

`is_symlink`

bool is_symlink(file_status stat) noexcept;
bool is_symlink(const path& pval);
bool is_symlink(const path& pval, error_code& ec) noexcept;

Die erste Funktion gibt zurück stat.type() == file_type::symlink. Die verbleibenden Funktionen geben zurück is_symlink(status(pval)).

`last_write_time`

file_time_type last_write_time(const path& pval);
file_time_type last_write_time(const path& pval, error_code& ec) noexcept;
void last_write_time(const path& pval, file_time_type new_time);
void last_write_time(const path& pval, file_time_type new_time, error_code& ec) noexcept;

Die ersten beiden Funktionen geben den Zeitpunkt der letzten Datenänderung für pval, oder file_time_type(-1) wenn ein Fehler auftritt. Die letzten beiden Funktionen legen den Zeitpunkt der letzten Datenänderung auf pvalnew_time.

`permissions`

void permissions(const path& pval, perms mask);
void permissions(const path& pval, perms mask, error_code& ec) noexcept;

Die Funktionen legen die Berechtigungen für den Pfadnamen fest, der unter pval Kontrolle von perms & (perms::add_perms | perms::remove_perms).mask & perms::mask mask enthält höchstens eine von perms::add_perms und perms::remove_perms.

Wenn mask & perms::add_perms, legen die Funktionen die Berechtigungen auf status(pval).permissions() | mask & perms::mask. mask & perms::remove_permsAndernfalls legen die Funktionen die Berechtigungen auf status(pval).permissions() & ~(mask & perms::mask). Andernfalls legen die Funktionen die Berechtigungen auf mask & perms::mask.

`read_symlink`

path read_symlink(const path& pval);
path read_symlink(const path& pval, error_code& ec);

Die Funktionen melden einen Fehler und geben zurück path() , wenn !is_symlink(pval). Andernfalls geben die Funktionen ein Objekt vom Typ path zurück, das die symbolische Verknüpfung enthält.

`remove`

bool remove(const path& pval);
bool remove(const path& pval, error_code& ec) noexcept;

Die Funktionen werden nur zurückgegeben true , wenn exists(symlink_status(pval)) die Datei erfolgreich entfernt wird. Ein Symlink wird selbst entfernt, nicht die ausgewählte Datei.

`remove_all`

uintmax_t remove_all(const path& pval);
uintmax_t remove_all(const path& pval, error_code& ec) noexcept;

Wenn pval es sich um ein Verzeichnis handelt, entfernen die Funktionen rekursiv alle Verzeichniseinträge und dann den Eintrag selbst. Andernfalls rufen die Funktionen auf remove. Sie geben eine Anzahl aller Elemente zurück, die erfolgreich entfernt wurden.

`rename`

void rename(const path& from, const path& to);
void rename(const path& from, const path& to, error_code& ec) noexcept;

Die Funktionen werden umbenannt from in to. Ein Symlink wird selbst umbenannt, nicht die ausgewählte Datei.

`resize_file`

void resize_file(const path& pval, uintmax_t size);
void resize_file(const path& pval, uintmax_t size, error_code& ec) noexcept;

Die Funktionen ändern die Größe einer Datei so, dass file_size(pval) == size.

`space`

space_info space(const path& pval);
space_info space(const path& pval, error_code& ec) noexcept;

Die Funktion gibt Informationen über das von pval, in einer Struktur vom Typ space_infoausgewählte Volume zurück. Die Struktur enthält uintmax_t(-1) einen beliebigen Wert, der nicht bestimmt werden kann.

`status`

file_status status(const path& pval);
file_status status(const path& pval, error_code& ec) noexcept;

Die Funktionen geben den Pfadnamenstatus, den Dateityp und die Berechtigungen zurück, die zugeordnet sind pval. Ein Symlink wird selbst nicht getestet, aber die datei, die er auswäht.

`status_known`

bool status_known(file_status stat) noexcept;

Die Funktion gibt zurück. stat.type() != file_type::none

`swap`

void swap(path& left, path& right) noexcept;

Die Funktion tauscht den Inhalt von links und rechts aus.

`symlink_status`

file_status symlink_status(const path& pval);
file_status symlink_status(const path& pval, error_code& ec) noexcept;

Die Funktionen geben den Pfadnamen symlink-Status, den Dateityp und berechtigungen zurück, die zugeordnet sind pval. Die Funktionen verhalten sich genauso, als status(pval) ob ein Symlink selbst getestet wird, nicht die ausgewählte Datei.

`system_complete`

Note

C++17 std::filesystem wird nicht bereitgestellt system_complete. Verwenden Sie std::filesystem::absolute für den aktuellen Code, wenn er das erforderliche Verhalten bereitstellt.

path system_complete(const path& pval);
path system_complete(const path& pval, error_code& ec);

Die Funktionen geben einen absoluten Pfadnamen zurück, der bei Bedarf das dem Stammnamen zugeordnete aktuelle Verzeichnis berücksichtigt. Für POSIX werden die Funktionen zurückgegeben absolute(pval).

`temp_directory_path`

path temp_directory_path();
path temp_directory_path(error_code& ec);

Die Funktionen geben einen Pfadnamen für ein Verzeichnis zurück, das für temporäre Dateien geeignet ist.

`u8path`

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

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

Die erste Funktion verhält sich genauso wie path(source) die zweite Funktion wie die zweite Funktion, path(first, last) mit der Ausnahme, dass die ausgewählte Quelle in jedem Fall als Sequenz von Zeichenelementen verwendet wird, die als UTF-8 codiert sind, unabhängig vom Dateisystem.

Siehe auch

<experimental/filesystem>
<experimental/filesystem> Aufzählungen
<experimental/filesystem> Operatoren

Feedback

War diese Seite hilfreich?

Zuletzt aktualisiert um 2026-08-31

<experimental/filesystem> Funktionen

Anforderungen

absolute

begin

canonical

copy

copy_file

copy_symlink

create_directories

create_directory

create_directory_symlink

create_hard_link

create_symlink

current_path

end

equivalent

exists

file_size

hard_link_count

hash_value

is_block_file

is_character_file

is_directory

is_empty

is_fifo

is_other

is_regular_file

is_socket

is_symlink

last_write_time

permissions

read_symlink

remove

remove_all

rename

resize_file

space

status

status_known

swap

symlink_status

system_complete

temp_directory_path

u8path