std::filesystem::copy

Copia archivos y directorios con una variedad de opciones.

El comportamiento es el siguiente:

• Primero, antes de hacer algo, se obtiene el tipo y permisos de from sin más de una sola 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 de lo contrario.

• Si es necesario, obtiene el estado de to, sin más de una sola llamada a

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

• Si 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, se informa de un error.
• Si from y to son el mismo archivo, como se determina por std::filesystem::equivalent, se informa de un error.
• Si from o to no es un archivo regular, un directorio, o un enlace simbólico, como se determina por std::filesystem::is_other, se informa de un error.
• Si from es un directorio, pero to es un archivo regular, se informa de 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, se informa de 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 de acceso absoluta, a menos que to se encuentre 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 copy_options::create_symlinks está establecida en options, se informa de 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).
• Entonces, si to ya existía o se acaba de crear, itera sobre los archivos contenidos en from como si fuera por 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 | en-copia-recursiva), donde en-copia-recursiva 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.

[editar] Parámetros

[editar] Valor de retorno

(Ninguno)

[editar] Excepciones

La sobrecarga que no toma un parámetro std::error_code& lanza filesystem::filesystem_error en los errores de la API del sistema operativo subyacente, construido con from como el primer argumento de la ruta de acceso, to como el segundo argumento de la ruta de acceso, y el código de error del sistema operativo como el argumento del código de error. La sobrecarga que toma un parámetro std::error_code& lo establece en el código de error de la API del sistema operativo si una llamada a la API del sistema operativo falla, y ejecuta ec.clear() si no ocurren errores. Cualquier sobrecarga que no está marcada con noexcept puede lanzar std::bad_alloc si la asignación de memoria falla.

[editar] Notas

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

// Dado que
// /dir1 contiene /dir1/file1, /dir1/file2, /dir1/dir2
// y /dir1/dir2 contiene /dir1/dir2/file3
// Después de
std::filesystem::copy("/dir1", "/dir3");
// /dir3 se crea (con los atributos de /dir1)
// /dir1/file1 se copia a /dir3/file1
// /dir1/file2 se copia a /dir3/file2

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

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

[editar] Ejemplo

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <filesystem>
namespace fs = std::filesystem;
 
int main()
{
    fs::create_directories("entorno/dir/subdir");
    std::ofstream("entorno/archivo1.txt").put('a');
    fs::copy("entorno/archivo1.txt", "entorno/archivo2.txt"); // copiar archivo
    fs::copy("entorno/dir", "entorno/dir2"); // copiar directorio (no recursivo)
    const auto opcDeCopia = fs::copy_options::update_existing
                           | fs::copy_options::recursive
                           | fs::copy_options::directories_only
                           ;
    fs::copy("entorno", "copia_de_entorno", opcDeCopia); 
    static_cast<void>(std::system("tree"));
    fs::remove_all("entorno");
    fs::remove_all("copia_de_entorno");
}

.
├── entorno
│   ├── dir
│   │   └── subdir
│   ├── dir2
│   ├── archivo1.txt
│   └── archivo2.txt
└── copia_de_entorno
    ├── dir
    │   └── subdir
    └── dir2
 
8 directorios, 2 archivos

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también