std::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 los permisos de from mediante no más de una única llamada a

• std::filesystem::symlink_status , si copy_options::skip_symlinks , copy_options::copy_symlinks , o copy_options::create_symlinks está presente en options ;
• std::filesystem::status en caso contrario.

• Si es necesario, obtiene el estado de to , mediante no más de una única llamada a

• std::filesystem::symlink_status , si copy_options::skip_symlinks o copy_options::create_symlinks está presente en options ;
• std::filesystem::status en caso contrario (incluyendo el caso donde copy_options::copy_symlinks está presente en options ).

• Si ya sea from o to tiene un tipo de archivo definido por la implementación, los efectos de esta función están definidos por la implementación.
• Si from no existe, reporta un error.
• Si from y to son el mismo archivo según lo determinado por std::filesystem::equivalent , reporta un error.
• Si ya sea from o to no es un archivo regular, un directorio o un enlace simbólico, según lo determinado por std::filesystem::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 fuera 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 fuera copy_file ( from, to, options ) (copia el archivo).

• De lo contrario, si from es un directorio y copy_options::create_symlinks está establecido en options , reporta un error con un código de error igual a std:: make_error_code ( std:: errc :: is_a_directory ) .
• 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 std:: filesystem :: directory_entry & x : std:: filesystem :: directory_iterator ( from ) ) y para cada entrada de directorio, llama recursivamente a copy ( x. path ( ) , to / x. path ( ) . filename ( ) , options | in - recursive - copy ) , donde in-recursive-copy es un bit especial que no tiene otro efecto cuando se establece en options . (El único propósito de establecer este bit es evitar la copia recursiva de subdirectorios si options es copy_options::none .)

• De lo contrario, no hace nada.

Parámetros

Valor de retorno

(ninguno)

Excepciones

Cualquier sobrecarga no marcada como noexcept puede lanzar std::bad_alloc si la asignación de memoria falla.

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::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::filesystem::copy("/dir1", "/dir3", std::filesystem::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 <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"); // copiar archivo
    fs::copy("sandbox/dir", "sandbox/dir2"); // copiar directorio (no recursivo)
    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 directorios, 2 archivos

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también