funciones<filesystem>

Estas funciones gratuitas en el encabezado de C++17 <filesystem> realizan operaciones de modificación y consulta en rutas de acceso, archivos, vínculos simbólicos, directorios y volúmenes. Para obtener más información y ejemplos de código, vea Exploración del sistema de archivos (C++).

Requisitos

Encabezado: <filesystem>

Espacio de nombres:std::filesystem

absolute

path absolute(const path& pval);
path absolute(const path& pval, error_code& ec);

Las funciones componen una ruta de acceso absoluta que hace referencia a la misma ubicación pvaldel sistema de archivos que , según la semántica del sistema operativo. La sobrecarga que toma ec devuelve path() si se produce un error.

begin

directory_iterator begin(directory_iterator iter) noexcept;
recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;

Ambas funciones devuelven iter. Junto con end, habilitan bucles basados en for intervalos a través de o directory_iteratorrecursive_directory_iterator.

canonical

path canonical(const path& pval);
path canonical(const path& pval, error_code& ec);

Las funciones convierten pval, que deben existir, en una ruta de acceso absoluta que hace referencia al mismo objeto del sistema de archivos y no tiene elementos de vínculo simbólico, punto o punto. La sobrecarga que toma ec devuelve path() si se produce un error.

copy

void copy(const path& from, const path& to);
void copy(const path& from, const path& to, error_code& ec) noexcept;
void copy(const path& from, const path& to, copy_options opts);
void copy(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Posiblemente, todas las funciones copian o vinculan uno o varios archivos de from a to bajo el control de opts, que se toma como copy_options::none para las sobrecargas que no tienen el parámetro opts. opts debe contener, como máximo, una de las siguientes opciones:

• skip_existing, overwrite_existingo update_existing

• copy_symlinks o skip_symlinks

• directories_only, create_symlinkso create_hard_links

En primer lugar, las funciones determinan los file_status valores fde yt para. Usan symlink_status cuando opts contiene copy_options::create_symlinks, copy_options::skip_symlinkso copy_options::copy_symlinks, según sea necesario para el origen o destino. De lo contrario, usan status.

Si !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t), informan de un error (y no hacen nada más).

De lo contrario, si is_symlink(f):

• Si options & copy_options::skip_symlinks, no debe hacer nada.

• De lo contrario, si !exists(t) && options & copy_options::copy_symlinks, copy_symlink(from, to).

• En caso contrario, notifican un error.

De lo contrario, si is_regular_file(f):

• Si opts & copy_options::directories_only, no debe hacer nada.

• De lo contrario, si opts & copy_options::create_symlinks, create_symlink(from, to).

• De lo contrario, si opts & copy_options::create_hard_links, create_hard_link(from, to).

• De lo contrario, si is_directory(t), copy_file(from, to / from.filename(), opts).

• En caso contrario, es copy_file(from, to, opts).

De lo contrario, si is_directory(f) && (opts & copy_options::recursive || !opts):

if (!exists(t))
{  // copy directory contents recursively
    create_directory(to, from, ec);

    for (directory_iterator next(from), end; ec == error_code() && next != end; ++next)
    {
        copy(next->path(), to / next->path().filename(), opts, ec);
    }
}

De lo contrario, no hacen nada.

copy_file

bool copy_file(const path& from, const path& to);
bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
bool copy_file(const path& from, const path& to, copy_options opts);
bool copy_file(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Posiblemente, todas las funciones copian el archivo que se encuentra en from a to bajo el control de opts, que se toma como copy_options::none para las sobrecargas que no tienen el parámetro opts. opts debe contener, como máximo, una de las siguientes opciones: skip_existing, overwrite_existing o update_existing.

Si exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), notifique como un error que el archivo ya existe.

De lo contrario, si !exists(to) || opts & copy_options::overwrite_existing || opts & copy_options::update_existing&& last_write_time(to) < last_write_time(from) || !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), intente copiar el contenido y los atributos del archivo from al archivo to. Notifican un error si se produce un error en el intento de copia.

Las funciones devuelven true si la copia se ha intentado y se realiza correctamente; en caso contrario, devuelven false.

copy_symlink

void copy_symlink(const path& from, const path& to);
void copy_symlink(const path& from, const path& to, error_code& ec) noexcept;

Si is_directory(from), la función llama a create_directory_symlink(from, to). En caso contrario, llama a create_symlink(from, to).

create_directories

bool create_directories(const path& pval);
bool create_directories(const path& pval, error_code& ec) noexcept;

Para un nombre de ruta de acceso como a\/b\/c, la función crea los directorios a y a\/b según sea necesario para poder crear el directorio a\/b\/c según sea necesario. Devuelve true solo si crea realmente el directorio pval.

create_directory

bool create_directory(const path& pval);

bool create_directory(const path& pval, error_code& ec) noexcept;
bool create_directory(const path& pval, const path& attr);
bool create_directory(const path& pval, const path& attr, error_code& ec) noexcept;

La función crea el directorio pval según sea necesario. Devuelve true solo si realmente crea el directorio pval, en cuyo caso copia los permisos del archivo attr existente o usa perms::all para las sobrecargas que no tienen el parámetro attr.

create_directory_symlink

void create_directory_symlink(const path& to, const path& link);
void create_directory_symlink(const path& to, const path& link, error_code& ec) noexcept;

La función crea el vínculo como un vínculo simbólico al directorio to.

create_hard_link

void create_hard_link(const path& to,  const path& link);
void create_hard_link(const path& to, const path& link, error_code& ec) noexcept;

La función crea el vínculo como un vínculo físico al directorio o archivo to.

create_symlink

void create_symlink(const path& to, const path& link);

void create_symlink(const path& to, const path& link, error_code& ec) noexcept;

La función crea link como un vínculo simbólico al archivo to.

current_path

path current_path();
path current_path(error_code& ec);
void current_path(const path& pval);
void current_path(const path& pval, error_code& ec) noexcept;

Las funciones que no tienen el parámetro pval devuelven el nombre de ruta de acceso del directorio actual. Las funciones restantes establecen el directorio actual en pval.

end

directory_iterator end(const directory_iterator&) noexcept;
recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;

La primera función devuelve directory_iterator() y la segunda función devuelve recursive_directory_iterator().

equivalent

bool equivalent(const path& left, const path& right);
bool equivalent(const path& left, const path& right, error_code& ec) noexcept;

Las funciones devuelven true solo si left y right seleccionan la misma entidad del sistema de archivos.

exists

bool exists(file_status stat) noexcept;
bool exists(const path& pval);
bool exists(const path& pval, error_code& ec) noexcept;

La primera función devuelve status_known(stat) && stat.type() != file_type::not_found. Las funciones segunda y tercera devuelven exists(status(pval)).

file_size

uintmax_t file_size(const path& pval);
uintmax_t file_size(const path& pval, error_code& ec) noexcept;

Las funciones devuelven el tamaño en bytes del archivo elegido por pval, si exists(pval) && is_regular_file(pval) y el tamaño del archivo se pueden determinar. En caso contrario, notifican un error y devuelven uintmax_t(-1).

hard_link_count

uintmax_t hard_link_count(const path& pval);
uintmax_t hard_link_count(const path& pval, error_code& ec) noexcept;

La función devuelve el número de vínculos físicos para pval, o -1 si se produce un error.

hash_value

size_t hash_value(const path& pval) noexcept;

La función devuelve un valor hash para pval.native().

is_block_file

bool is_block_file(file_status stat) noexcept;
bool is_block_file(const path& pval);
bool is_block_file(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::block. Las funciones restantes devuelven is_block_file(status(pval)).

is_character_file

bool is_character_file(file_status stat) noexcept;
bool is_character_file(const path& pval);
bool is_character_file(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::character. Las funciones restantes devuelven is_character_file(status(pval)).

is_directory

bool is_directory(file_status stat) noexcept;
bool is_directory(const path& pval);
bool is_directory(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::directory. Las funciones restantes devuelven is_directory(status(pval)).

is_empty

bool is_empty(const path& pval);
bool is_empty(const path& pval, error_code& ec) noexcept;

Si is_directory(pval), la función devuelve directory_iterator(pval) == directory_iterator(); de lo contrario, devuelve file_size(pval) == 0.

is_fifo

bool is_fifo(file_status stat) noexcept;
bool is_fifo(const path& pval);
bool is_fifo(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::fifo. Las funciones restantes devuelven is_fifo(status(pval)).

is_other

bool is_other(file_status stat) noexcept;
bool is_other(const path& pval);
bool is_other(const path& pval, error_code& ec) noexcept;

La primera función devuelve exists(stat) && !is_regular_file(stat) && !is_directory(stat) && !is_symlink(stat). Las funciones restantes devuelven is_other(status(pval)).

is_regular_file

bool is_regular_file(file_status stat) noexcept;
bool is_regular_file(const path& pval);
bool is_regular_file(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::regular. Las funciones restantes devuelven is_regular_file(status(pval)).

is_socket

bool is_socket(file_status stat) noexcept;
bool is_socket(const path& pval);
bool is_socket(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::socket. Las funciones restantes devuelven is_socket(status(pval)).

is_symlink

bool is_symlink(file_status stat) noexcept;
bool is_symlink(const path& pval);
bool is_symlink(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::symlink. Las funciones restantes devuelven is_symlink(status(pval)).

last_write_time

file_time_type last_write_time(const path& pval);
file_time_type last_write_time(const path& pval, error_code& ec) noexcept;
void last_write_time(const path& pval, file_time_type new_time);
void last_write_time(const path& pval, file_time_type new_time, error_code& ec) noexcept;

Las dos primeras funciones devuelven la hora de la última modificación de datos de pval, o file_time_type(-1) si se produce un error. Las dos últimas funciones establecen la hora de la última modificación de datos de pval en new_time.

permissions

void permissions(const path& pval, perms mask, perm_options opts = perm_options::replace);
void permissions(const path& pval, perms mask, error_code& ec) noexcept;
void permissions(const path& pval, perms mask, perm_options opts, error_code& ec);

Las funciones establecen los permisos para el nombre de ruta de acceso elegido por pval para mask & perms::mask bajo el control de opts. opts debe contener exactamente uno de perm_options::replacelos valores , perm_options::addo perm_options::removey, opcionalmente perm_options::nofollow, . Las sobrecargas sin opts parámetro se comportan como si opts fuera perm_options::replace.

Si opts & perm_options::add, las funciones establecen los permisos en status(pval).permissions() | (mask & perms::mask). En caso contrario, si opts & perm_options::remove, las funciones establecen los permisos en status(pval).permissions() & ~(mask & perms::mask). En caso contrario, las funciones establecen los permisos en mask & perms::mask. Si opts & perm_options::nofollow y pval asigna un nombre a un vínculo simbólico, las funciones cambian los permisos del vínculo simbólico en lugar del archivo al que se resuelve.

proximate

path proximate(const path& p, error_code& ec);
path proximate(const path& p, const path& base = current_path());
path proximate(const path& p, const path& base, error_code& ec);

La primera sobrecarga devuelve proximate(p, current_path(), ec). Las otras sobrecargas devuelven el resultado de aplicar lexically_proximate a las formas canónicas débiles de p y base. La sobrecarga que toma ec devuelve path() si se produce un error.

read_symlink

path read_symlink(const path& pval);
path read_symlink(const path& pval, error_code& ec);

Las funciones notifican un error y devuelven path() si !is_symlink(pval). De lo contrario, las funciones devuelven un objeto de tipo path que tiene el vínculo simbólico.

relative

path relative(const path& p, error_code& ec);
path relative(const path& p, const path& base = current_path());
path relative(const path& p, const path& base, error_code& ec);

La primera sobrecarga devuelve relative(p, current_path(), ec). Las otras sobrecargas devuelven el resultado de aplicar lexically_relative a las formas canónicas débiles de p y base. La sobrecarga que toma ec devuelve path() si se produce un error.

remove

bool remove(const path& pval);
bool remove(const path& pval, error_code& ec) noexcept;

Las funciones devuelven true solo si exists(symlink_status(pval)) y el archivo se quita correctamente. Se quita un vínculo simbólico, no el archivo que este selecciona.

remove_all

uintmax_t remove_all(const path& pval);
uintmax_t remove_all(const path& pval, error_code& ec) noexcept;

Si pval es un directorio, las funciones quitan todas las entradas de directorio de forma recursiva y luego la entrada en sí. De lo contrario, las funciones llaman a remove. Devuelven un recuento de todos los elementos que se quitaron correctamente.

rename

void rename(const path& from, const path& to);
void rename(const path& from, const path& to, error_code& ec) noexcept;

Las funciones cambian el nombre de from a to. Se cambia el nombre de un vínculo simbólico, no del archivo que este selecciona.

resize_file

void resize_file(const path& pval, uintmax_t size);
void resize_file(const path& pval, uintmax_t size, error_code& ec) noexcept;

Las funciones modifican el tamaño de un archivo de forma que file_size(pval) == size.

space

space_info space(const path& pval);
space_info space(const path& pval, error_code& ec) noexcept;

La función devuelve información sobre el volumen selecciona por pval, en una estructura de tipo space_info. La estructura contiene uintmax_t(-1) para cualquier valor que no se puede determinar.

status

file_status status(const path& pval);
file_status status(const path& pval, error_code& ec) noexcept;

Las funciones devuelven el estado del nombre de ruta de acceso, el tipo de archivo y los permisos asociados a pval. No se comprueba un vínculo simbólico, sino el archivo que este selecciona.

status_known

bool status_known(file_status stat) noexcept;

La función devuelve stat.type() != file_type::none.

swap

void swap(path& left, path& right) noexcept;

La función intercambia el contenido de left y right.

symlink_status

file_status symlink_status(const path& pval);
file_status symlink_status(const path& pval, error_code& ec) noexcept;

Las funciones devuelven el estado de vínculo simbólico del nombre de ruta de acceso, el tipo de archivo y los permisos asociados a pval. Las funciones se comportan igual que status(pval), excepto que se prueba un vínculo simbólico en sí, pero no el archivo que este selecciona.

temp_directory_path

path temp_directory_path();
path temp_directory_path(error_code& ec);

Las funciones devuelven un nombre de ruta de acceso de un directorio adecuado para contener los archivos temporales.

u8path

template <class Source>
path u8path(const Source& source);

template <class InIt>
path u8path(InIt first, InIt last);

La primera función se comporta igual que path(source) y la segunda función se comporta igual que path(first, last), excepto que el origen seleccionado en cada caso se toma como una secuencia de elementos char codificados como UTF-8, independientemente del sistema de archivos.

weakly_canonical

path weakly_canonical(const path& p);
path weakly_canonical(const path& p, error_code& ec);

Estas funciones devuelven una ruta de acceso en forma canónica, como la canonical función, pero la ruta de acceso no necesita existir.

Consulte también

Referencia de archivos de encabezado
<filesystem>
Navegación del sistema de archivos (C++)