std::filesystem::copy

Definido en el archivo de encabezado `<filesystem>`
`void copy( const std::filesystem::path& from, const std::filesystem::path& to ); void copy( const std::filesystem::path& from, const std::filesystem::path& to, std::error_code& ec );`	(1)	(desde C++17)
`void copy( const std::filesystem::path& from, const std::filesystem::path& to, std::filesystem::copy_options options ); void copy( const std::filesystem::path& from, const std::filesystem::path& to, std::filesystem::copy_options options, std::error_code& ec );`	(2)	(desde C++17)

Copia archivos y directorios con una variedad de opciones.

1) Por defecto. Es equivalente a (2) con copy_options::none utilizada como options.

2) Copia el archivo o directorio from al archivo o directorio to, utilizando las opciones de copia indicadas por options. El comportamiento no está definido si hay más de una opción en alguna de las opciones de copia copy_options presentes en el grupo de opciones options (incluso en el grupo copy_file).

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.

Parámetros

from	-	La ruta de acceso al archivo, directorio o enlace simbólico fuente.
to	-	La ruta de acceso al archivo, directorio o enlace simbólico destino.
ec	-	El parámetro de salida para informe de errores en la sobrecarga que no lanza excepciones.

Valor de retorno

(Ninguno)

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.

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

Ejemplo

Este ejemplo demuestra la copia de archivos y directorios de forma no recursiva y recursiva. Requiere que el programa tree esté presente para generar el árbol de directorios.

Ejecuta este código

#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");
}

Posible salida:

.
├── entorno
│   ├── dir
│   │   └── subdir
│   ├── dir2
│   ├── archivo1.txt
│   └── archivo2.txt
└── copia_de_entorno
    ├── dir
    │   └── subdir
    └── dir2

8 directorios, 2 archivos

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.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 3013	C++17	La sobrecarga con `error_code` está marcada con `noexcept` pero puede asignar memoria.	Se eliminó `noexcept`.
LWG 2682	C++17	Intentar crear un enlace simbólico para un directorio tiene éxito pero no hace nada.	Se informa de un error.

Véase también

copy_options (C++17)	Especifica la semántica de las operaciones de copia. (enum) [editar]
copy_symlink (C++17)	Copia un enlace simbólico. (función) [editar]
copy_file (C++17)	Copia el contenido de un archivo. (función) [editar]

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones