std::experimental::filesystem::copy

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Experimentell

Technische Spezifikation

Dateisystembibliothek (Filesystem TS)

Grundlagen der Bibliothek (Library Fundamentals TS)

Grundlagen der Bibliothek 2 (Library Fundamentals TS v2)

Grundlagen der Bibliothek 3 (Library Fundamentals TS v3)

Erweiterungen für Parallelität (Parallelism TS)

Erweiterungen für Parallelität 2 (Parallelism TS v2)

Erweiterungen für Nebenläufigkeit (Concurrency TS)

Erweiterungen für Nebenläufigkeit 2 (Concurrency TS v2)

Konzepte (Concepts TS)

Bereiche (Ranges TS)

Reflektion (Reflection TS)

Mathematische Spezialfunktionen (Special Functions TR)

Experimentell Nicht-TS

Pattern Matching

Lineare Algebra

std::execution

Verträge

2D-Grafik

 

Dateisystem-Bibliothek

Klassen
filesystem::path filesystem::filesystem_error filesystem::directory_entry filesystem::directory_iterator filesystem::recursive_directory_iterator filesystem::file_status	filesystem::space_info filesystem::file_type filesystem::perms filesystem::copy_options filesystem::directory_options filesystem::file_time_type
Funktionen
filesystem::absolute filesystem::system_complete filesystem::canonical filesystem::copy filesystem::copy_file filesystem::copy_symlink filesystem::create_directory filesystem::create_directories filesystem::create_hard_link filesystem::create_symlink filesystem::create_directory_symlink filesystem::current_path filesystem::exists filesystem::equivalent	filesystem::file_size filesystem::hard_link_count filesystem::last_write_time filesystem::permissions filesystem::read_symlink filesystem::remove filesystem::remove_all filesystem::rename filesystem::resize_file filesystem::space filesystem::status filesystem::symlink_status filesystem::temp_directory_path
Dateitypen
filesystem::is_block_file filesystem::is_character_file filesystem::is_directory filesystem::is_empty filesystem::status_known	filesystem::is_fifo filesystem::is_other filesystem::is_regular_file filesystem::is_socket filesystem::is_symlink

 

Definiert im Header <experimental/filesystem>
void copy( const path& from, const path& to ); void copy( const path& from, const path& to, error_code& ec );	(1)	(Dateisystem-TS)
void copy( const path& from, const path& to, copy_options options ); void copy( const path& from, const path& to, copy_options options, error_code& ec );	(2)	(Dateisystem-TS)

Kopiert Dateien und Verzeichnisse mit einer Vielzahl von Optionen

1) Die Standardvariante, äquivalent zu (2) mit copy_options::none als options.

2) Kopiert die Datei oder das Verzeichnis from in die Datei oder das Verzeichnis to, unter Verwendung der durch options angegebenen Kopieroptionen. Das Verhalten ist undefiniert, wenn mehr als eine Option in einer der copy_options-Optionsgruppen in options vorhanden ist (auch in der Gruppe copy_file, die für copy nicht relevant ist).

Das Verhalten ist wie folgt:

• Zuerst, bevor irgendetwas anderes geschieht, wird der Typ und die Berechtigungen von from durch nicht mehr als einen Aufruf von status ermittelt (oder, wenn copy_options::skip_symlinks oder copy_options::create_symlinks in options vorhanden sind, durch einen Aufruf von symlink_status).
• Falls notwendig, wird der Status von to auf die gleiche Weise ermittelt, durch nicht mehr als einen Status- oder Symlink_Status-Aufruf.
• Wenn from nicht existiert, wird ein Fehler gemeldet.
• Wenn from und to dieselbe Datei sind, wie durch equivalent() bestimmt, wird ein Fehler gemeldet.
• Wenn entweder from oder to keine reguläre Datei, kein Verzeichnis und kein Symlink ist, wie durch is_other bestimmt, wird ein Fehler gemeldet.
• Wenn from ein Verzeichnis ist, to aber eine reguläre Datei ist, wird ein Fehler gemeldet.
• Wenn from ein symbolischer Link ist, dann:

• Wenn copy_options::skip_symlink in options vorhanden ist, geschieht nichts.
• Andernfalls, wenn to nicht existiert und copy_options::copy_symlinks in options vorhanden ist, verhält es sich so, als ob copy_symlink(from, to) aufgerufen würde.
• Andernfalls wird ein Fehler gemeldet.

• Andernfalls, wenn from eine reguläre Datei ist, dann:

• Wenn copy_options::directories_only in options vorhanden ist, geschieht nichts.
• Andernfalls, wenn copy_options::create_symlinks in options vorhanden ist, wird ein Symlink zu to erstellt. Hinweis: from muss ein absoluter Pfad sein, es sei denn, to befindet sich im aktuellen Verzeichnis.
• Andernfalls, wenn copy_options::create_hard_links in options vorhanden ist, wird ein Hardlink zu to erstellt.
• Andernfalls, wenn to ein Verzeichnis ist, verhält es sich so, als ob copy_file(from, to/from.filename(), options) aufgerufen würde (erstellt eine Kopie von from als Datei im Verzeichnis to).
• Andernfalls verhält es sich so, als ob copy_file(from, to, options) aufgerufen würde (kopiert die Datei).

• Andernfalls, wenn from ein Verzeichnis ist und entweder options copy_options::recursive enthält oder gleich copy_options::none ist.

• Wenn to nicht existiert, wird zuerst create_directory(to, from) ausgeführt (erstellt das neue Verzeichnis mit einer Kopie der Attribute des alten Verzeichnisses).
• Dann, unabhängig davon, ob to bereits existierte oder gerade erstellt wurde, werden die Dateien in from iteriert, als ob durch for (const directory_entry& x : directory_iterator(from)) und für jeden Verzeichniseintrag wird rekursiv copy(x.path(), to/x.path().filename(), options | unspecified) aufgerufen, wobei unspecified ein spezielles Bit ist, das keine andere Auswirkung hat, wenn es in options gesetzt ist (der einzige Zweck dieses Bits ist es, die rekursive Kopie von Unterverzeichnissen zu verhindern, wenn options copy_options::none ist).

• Andernfalls geschieht nichts.

Parameter

from	-	Pfad zur Quellendatei, zum Quellverzeichnis oder zum Quell-Symlink
to	-	Pfad zur Zieldatei, zum Zielverzeichnis oder zum Ziel-Symlink
ec	-	Ausgabeparameter für die Fehlerberichterstattung in der nicht auslösenden Überladung

Rückgabewert

(keine)

Ausnahmen

Die Überladung, die keinen error_code&-Parameter hat, wirft eine filesystem_error bei zugrundeliegenden Betriebssystem-API-Fehlern, konstruiert mit from als erstem Argument, to als zweitem Argument und dem Betriebssystem-Fehlercode als Fehlercode-Argument. std::bad_alloc kann geworfen werden, wenn die Speicherzuweisung fehlschlägt. Die Überladung, die einen error_code&-Parameter annimmt, setzt diesen auf den Betriebssystem-API-Fehlercode, wenn ein Betriebssystem-API-Aufruf fehlschlägt, und führt ec.clear() aus, wenn keine Fehler auftreten. Diese Überladung hat

noexcept-Spezifikation:  

noexcept

  

Hinweise

Das Standardverhalten beim Kopieren von Verzeichnissen ist das nicht-rekursive Kopieren: Die Dateien werden kopiert, aber nicht die Unterverzeichnisse.

// Given
// /dir1 contains /dir1/file1, /dir1/file2, /dir1/dir2
// and /dir1/dir2 contains /dir1/dir2/file3
// After
std::experimental::filesystem::copy("/dir1", "/dir3");
// /dir3 is created (with the attributes of /dir1)
// /dir1/file1 is copied to /dir3/file1
// /dir1/file2 is copied to /dir3/file2

Während mit copy_options::recursive auch die Unterverzeichnisse mit ihrem Inhalt rekursiv kopiert werden.

// ...but after
std::experimental::filesystem::copy("/dir1", "/dir3", copy_options::recursive);
// /dir3 is created (with the attributes of /dir1)
// /dir1/file1 is copied to /dir3/file1
// /dir1/file2 is copied to /dir3/file2
// /dir3/dir2 is created (with the attributes of /dir1/dir2)
// /dir1/dir2/file3 is copied to /dir3/dir2/file3

Beispiel

Führen Sie diesen Code aus

#include <experimental/filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::experimental::filesystem;
 
int main()
{
    fs::create_directories("sandbox/dir/subdir");
    std::ofstream("sandbox/file1.txt").put('a');
    fs::copy("sandbox/file1.txt", "sandbox/file2.txt"); // copy file
    fs::copy("sandbox/dir", "sandbox/dir2"); // copy directory (non-recursive)
    // sandbox holds 2 files and 2 directories, one of which has a subdirectory
    // sandbox/file1.txt
    // sandbox/file2.txt
    // sandbox/dir2
    // sandbox/dir
    //    sandbox/dir/subdir
    fs::copy("sandbox", "sandbox/copy", fs::copy_options::recursive);
    // sandbox/copy holds copies of the above files and subdirectories
    fs::remove_all("sandbox");
}

Siehe auch

copy_options	spezifiziert die Semantik von Kopiervorgängen (Aufzählung)
copy_symlink	kopiert einen symbolischen Link (Funktion)
copy_file	kopiert Dateiinhalte (Funktion)