std::experimental::filesystem:: copy

Copia archivos y directorios, con una variedad de opciones:

El comportamiento es el siguiente:

• Primero, antes de hacer cualquier otra cosa, obtiene el tipo y permisos de from mediante no más de una llamada a status (o, si copy_options::skip_symlinks o copy_options::create_symlinks están presentes en options , mediante una llamada a symlink_status ).
• Si es necesario, obtiene el estado de to de la misma manera, mediante no más de una llamada a status o symlink_status.
• Si from no existe, reporta un error.
• Si from y to son el mismo archivo según lo determinado por equivalent() , reporta un error.
• Si from o to no es un archivo regular, un directorio o un enlace simbólico, según lo determinado por is_other , reporta un error.
• Si from es un directorio, pero to es un archivo regular, reporta un error.
• Si from es un enlace simbólico, entonces

• Si copy_options::skip_symlink está presente en options , no hace nada.
• De lo contrario, si to no existe y copy_options::copy_symlinks está presente en options , entonces se comporta como si copy_symlink ( from, to ) .
• De lo contrario, reporta un error.

• De lo contrario, si from es un archivo regular, entonces

• Si copy_options::directories_only está presente en options , no hace nada.
• De lo contrario, si copy_options::create_symlinks está presente en options , crea un enlace simbólico a to . Nota: from debe ser una ruta absoluta a menos que to esté en el directorio actual.
• De lo contrario, si copy_options::create_hard_links está presente en options , crea un enlace físico a to .
• De lo contrario, si to es un directorio, entonces se comporta como si copy_file ( from, to / from. filename ( ) , options ) (crea una copia de from como un archivo en el directorio to ).
• De lo contrario, se comporta como si copy_file ( from, to, options ) (copia el archivo).

• De lo contrario, si from es un directorio y ya sea que options tenga copy_options::recursive o sea copy_options::none .

• Si to no existe, primero ejecuta create_directory ( to, from ) (crea el nuevo directorio con una copia de los atributos del directorio antiguo).
• Luego, ya sea que to ya existiera o acabe de ser creado, itera sobre los archivos contenidos en from como si fuera mediante for ( const directory_entry & x : directory_iterator ( from ) ) y para cada entrada de directorio, llama recursivamente a copy ( x. path ( ) , to / x. path ( ) . filename ( ) , options | unspecified ) , donde unspecified es un bit especial que no tiene otro efecto cuando se establece en options (el único propósito de establecer este bit es prevenir la copia recursiva de subdirectorios si options es copy_options::none ).

• De lo contrario, no hace nada.

Parámetros

Valor de retorno

(ninguno)

Excepciones

Notas

El comportamiento predeterminado al copiar directorios es la copia no recursiva: los archivos se copian, pero no los subdirectorios:

// Dado
// /dir1 contiene /dir1/file1, /dir1/file2, /dir1/dir2
// y /dir1/dir2 contiene /dir1/dir2/file3
// Después
std::experimental::filesystem::copy("/dir1", "/dir3");
// /dir3 es creado (con los atributos de /dir1)
// /dir1/file1 es copiado a /dir3/file1
// /dir1/file2 es copiado a /dir3/file2

Mientras que con copy_options::recursive , los subdirectorios también se copian, con su contenido, recursivamente.

// ...pero después
std::experimental::filesystem::copy("/dir1", "/dir3", copy_options::recursive);
// /dir3 es creado (con los atributos de /dir1)
// /dir1/file1 es copiado a /dir3/file1
// /dir1/file2 es copiado a /dir3/file2
// /dir3/dir2 es creado (con los atributos de /dir1/dir2)
// /dir1/dir2/file3 es copiado a /dir3/dir2/file3

Ejemplo

#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"); // copiar archivo
    fs::copy("sandbox/dir", "sandbox/dir2"); // copiar directorio (no recursivo)
    // sandbox contiene 2 archivos y 2 directorios, uno de los cuales tiene un subdirectorio
    // sandbox/file1.txt
    // sandbox/file2.txt
    // sandbox/dir2
    // sandbox/dir
    //    sandbox/dir/subdir
    fs::copy("sandbox", "sandbox/copy", fs::copy_options::recursive);
    // sandbox/copy contiene copias de los archivos y subdirectorios anteriores
    fs::remove_all("sandbox");
}

Véase también