std::filesystem:: copy

Copie les fichiers et répertoires, avec diverses options.

Le comportement est le suivant :

• Premièrement, avant toute autre chose, obtient le type et les permissions de from par pas plus d'un seul appel à

• std::filesystem::symlink_status , si copy_options::skip_symlinks , copy_options::copy_symlinks , ou copy_options::create_symlinks est présent dans options ;
• std::filesystem::status sinon.

• Si nécessaire, obtient le statut de to , par pas plus d'un seul appel à

• std::filesystem::symlink_status , si copy_options::skip_symlinks ou copy_options::create_symlinks est présent dans options ;
• std::filesystem::status sinon (y compris le cas où copy_options::copy_symlinks est présent dans options ).

• Si l'un des deux, from ou to a un type de fichier défini par l'implémentation, les effets de cette fonction sont définis par l'implémentation.
• Si from n'existe pas, signale une erreur.
• Si from et to correspondent au même fichier tel que déterminé par std::filesystem::equivalent , signale une erreur.
• Si l'un des deux, from ou to n'est pas un fichier régulier, un répertoire ou un lien symbolique, tel que déterminé par std::filesystem::is_other , signale une erreur.
• Si from est un répertoire, mais que to est un fichier régulier, signale une erreur.
• Si from est un lien symbolique, alors

• Si copy_options::skip_symlink est présent dans options , ne fait rien.
• Sinon, si to n'existe pas et copy_options::copy_symlinks est présent dans options , alors se comporte comme copy_symlink ( from, to ) .
• Sinon, signale une erreur.

• Sinon, si from est un fichier régulier, alors

• Si copy_options::directories_only est présent dans options , ne fait rien.
• Sinon, si copy_options::create_symlinks est présent dans options , crée un lien symbolique vers to . Note : from doit être un chemin absolu sauf si to se trouve dans le répertoire courant.
• Sinon, si copy_options::create_hard_links est présent dans options , crée un lien physique vers to .
• Sinon, si to est un répertoire, se comporte comme copy_file ( from, to / from. filename ( ) , options ) (crée une copie de from en tant que fichier dans le répertoire to ).
• Sinon, se comporte comme copy_file ( from, to, options ) (copie le fichier).

• Sinon, si from est un répertoire et que copy_options::create_symlinks est défini dans options , signale une erreur avec un code d'erreur égal à std:: make_error_code ( std:: errc :: is_a_directory ) .
• Sinon, si from est un répertoire et que soit options contient copy_options::recursive , soit est égal à copy_options::none ,

• Si to n'existe pas, exécute d'abord create_directory ( to, from ) (crée le nouveau répertoire avec une copie des attributs de l'ancien répertoire).
• Ensuite, que to existe déjà ou ait été créé, itère sur les fichiers contenus dans from comme si par for ( const std:: filesystem :: directory_entry & x : std:: filesystem :: directory_iterator ( from ) ) et pour chaque entrée de répertoire, appelle récursivement copy ( x. path ( ) , to / x. path ( ) . filename ( ) , options | in - recursive - copy ) , où in-recursive-copy est un bit spécial qui n'a aucun autre effet lorsqu'il est défini dans options . (Le seul but de définir ce bit est d'empêcher la copie récursive des sous-répertoires si options est copy_options::none .)

• Sinon, ne fait rien.

Paramètres

Valeur de retour

(aucun)

Exceptions

Toute surcharge non marquée noexcept peut lever std::bad_alloc si l'allocation de mémoire échoue.

Notes

Le comportement par défaut lors de la copie de répertoires est la copie non récursive : les fichiers sont copiés, mais pas les sous-répertoires :

// Étant donné
// /dir1 contient /dir1/file1, /dir1/file2, /dir1/dir2
// et /dir1/dir2 contient /dir1/dir2/file3
// Après
std::filesystem::copy("/dir1", "/dir3");
// /dir3 est créé (avec les attributs de /dir1)
// /dir1/file1 est copié vers /dir3/file1
// /dir1/file2 est copié vers /dir3/file2

Alors qu'avec copy_options::recursive , les sous-répertoires sont également copiés, avec leur contenu, de manière récursive.

// ...mais après
std::filesystem::copy("/dir1", "/dir3", std::filesystem::copy_options::recursive);
// /dir3 est créé (avec les attributs de /dir1)
// /dir1/file1 est copié vers /dir3/file1
// /dir1/file2 est copié vers /dir3/file2
// /dir3/dir2 est créé (avec les attributs de /dir1/dir2)
// /dir1/dir2/file3 est copié vers /dir3/dir2/file3

Exemple

#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;
int main()
{
    fs::create_directories("sandbox/dir/subdir");
    std::ofstream("sandbox/file1.txt").put('a');
    fs::copy("sandbox/file1.txt", "sandbox/file2.txt"); // copier le fichier
    fs::copy("sandbox/dir", "sandbox/dir2"); // copier le répertoire (non récursif)
    const auto copyOptions = fs::copy_options::update_existing
                           | fs::copy_options::recursive
                           | fs::copy_options::directories_only
                           ;
    fs::copy("sandbox", "sandbox_copy", copyOptions); 
    static_cast<void>(std::system("tree"));
    fs::remove_all("sandbox");
    fs::remove_all("sandbox_copy");
}

.
├── sandbox
│   ├── dir
│   │   └── subdir
│   ├── dir2
│   ├── file1.txt
│   └── file2.txt
└── sandbox_copy
    ├── dir
    │   └── subdir
    └── dir2
8 répertoires, 2 fichiers

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi