std::experimental::filesystem::copy_file

 

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>
bool copy_file( const path& from, const path& to ); bool copy_file( const path& from, const path& to, error_code& ec );	(1)	(Dateisystem-TS)
bool copy_file( const path& from, const path& to, copy_options options ); bool copy_file( const path& from, const path& to, copy_options options, error_code& ec );	(2)	(Dateisystem-TS)

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

2) Kopiert eine einzelne Datei von from nach to unter Verwendung der durch options angegebenen Kopiervorgänge. Das Verhalten ist undefiniert, wenn mehr als eine Option in einer der copy_options-Optionsgruppen in options vorhanden ist (auch in den Gruppen, die für copy_file nicht relevant sind).

• Wenn die Zieldatei nicht existiert,

• werden der Inhalt und die Attribute der Datei, auf die from aufgelöst wird, in die Datei kopiert, auf die to aufgelöst wird (Symbolische Links werden verfolgt).

• Andernfalls, wenn die Zieldatei bereits existiert

• Wenn to und from gemäß equivalent(from, to) identisch sind, wird ein Fehler gemeldet.
• Andernfalls, wenn keine der Steueroptionen von copy_file in options gesetzt ist, wird ein Fehler gemeldet.
• Andernfalls, wenn copy_options::skip_existing in options gesetzt ist, wird nichts unternommen.
• Andernfalls, wenn copy_options::overwrite_existing in options gesetzt ist, werden der Inhalt und die Attribute der Datei, auf die from aufgelöst wird, in die Datei kopiert, auf die to aufgelöst wird.
• Andernfalls, wenn copy_options::update_existing in options gesetzt ist, wird die Datei nur kopiert, wenn from neuer ist als to, wie durch last_write_time() definiert.

Die nicht-werfenden Überladungen geben false zurück, wenn ein Fehler auftritt.

Parameter

from	-	Pfad zur Quelldatei
to	-	Pfad zur Zieldatei
ec	-	Ausgabeparameter für die Fehlerberichterstattung in der nicht auslösenden Überladung

Rückgabewert

true, wenn die Datei kopiert wurde, false andernfalls.

Ausnahmen

Die Überladung, die keinen error_code&-Parameter annimmt, wirft filesystem_error bei zugrunde liegenden 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

Die Funktionen beinhalten höchstens einen direkten oder indirekten Aufruf von status(to) (verwendet sowohl zur Bestimmung, ob die Datei existiert, als auch, für die Option copy_options::update_existing, ihrer letzten Schreibzeit).

Ein Fehler wird gemeldet, wenn copy_file zum Kopieren eines Verzeichnisses verwendet wird: Verwenden Sie stattdessen copy.

copy_file folgt Symbolischen Links: Verwenden Sie copy_symlink oder copy mit copy_options::copy_symlinks dafür.

Beispiel

Führen Sie diesen Code aus

#include <experimental/filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::experimental::filesystem;
 
int main()
{
    fs::create_directory("sandbox");
    std::ofstream("sandbox/file1.txt").put('a');
 
    fs::copy_file("sandbox/file1.txt", "sandbox/file2.txt");
 
    // now there are two files in sandbox:
    std::cout << "file1.txt holds : "
              << std::ifstream("sandbox/file1.txt").rdbuf() << '\n';
    std::cout << "file2.txt holds : "
              << std::ifstream("sandbox/file2.txt").rdbuf() << '\n';
 
    // fail to copy directory
    fs::create_directory("sandbox/abc");
    try
    {
        fs::copy_file("sandbox/abc", "sandbox/def");
    }
    catch (fs::filesystem_error& e)
    {
        std::cout << "Could not copy sandbox/abc: " << e.what() << '\n';
    }
    fs::remove_all("sandbox");
}

Mögliche Ausgabe

file1.txt holds : a
file2.txt holds : a
Could not copy sandbox/abc: copy_file: Is a directory: "sandbox/abc", "sandbox/def"

Siehe auch

copy_options	spezifiziert die Semantik von Kopiervorgängen (Aufzählung)
copy_symlink	kopiert einen symbolischen Link (Funktion)
copy	kopiert Dateien oder Verzeichnisse (Funktion)