Compartir por

funciones<filesystem>

  • Artigo

Estas funciones libres del encabezado <filesystem> hacen 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++).

absolute

path absolute(const path& pval, const path& base = current_path());

La función devuelve el nombre de ruta de acceso absoluta correspondiente a un pval en relación con el nombre de ruta de acceso base:

  1. Si pval.has_root_name() && pval.has_root_directory(), la función devuelve pval.

  2. Si pval.has_root_name() && !pval.has_root_directory(), la función devuelve pval.root_name() / absolute(base).root_directory() / absolute(base).relative_path() / pval.relative_path().

  3. Si !pval.has_root_name() && pval.has_root_directory(), la función devuelve absolute(base).root_name() / pval.

  4. Si !pval.has_root_name() && !pval.has_root_directory(), la función devuelve absolute(base) / pval.

begin

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

Ambas funciones devuelven iter.

canonical

path canonical(const path& pval, const path& base = current_path());
path canonical(const path& pval, error_code& ec);
path canonical(const path& pval, const path& base, error_code& ec);

Todas las funciones forman un nombre de ruta de acceso absoluta pabs = absolute(pval, base) (o pabs = absolute(pval) para la sobrecarga sin parámetros de base) y, luego, lo reducen a una forma canónica en la siguiente secuencia de pasos:

  1. Cada componente de ruta X para el que is_symlink(X) es true se reemplaza por read_symlink(X).

  2. Cada componente de ruta de acceso . (el punto es el directorio actual establecido por los componentes de ruta de acceso anteriores) se quita.

  3. Cada par de componentes de ruta de acceso X/.. (los dos puntos son el directorio primario establecido por los componentes de ruta de acceso anteriores) se quita.

Después, la función devuelve pabs.

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

Las funciones primero determinan los valores file_status f para from y t para to:

  • Si opts & (copy_options::create_symlinks | copy_options::skip_symlinks), mediante una llamada a symlink_status.

  • De lo contrario, mediante una llamada a status.

  • En caso contrario, notifican un error.

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, opts).

  • 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(to, from).

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

  • De lo contrario, si is_directory(f), 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.

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.

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.

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.

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& iter) noexcept;
recursive_directory_iterator& end(const recursive_directory_iterator& iter) noexcept;

La primera función devuelve directory_iterator() y la segunda, 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.type() != file_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).

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_file(status(pval)).

is_empty

bool is_empty(file_status stat) noexcept;
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 stat.type() == file_type::other. 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)).

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);
void permissions(const path& pval, perms mask, error_code& ec) noexcept;

Las funciones establecen los permisos para el nombre de ruta de acceso elegido por pval para mask & perms::mask bajo el control de perms & (perms::add_perms | perms::remove_perms). mask debe contener, como máximo, una de las siguientes opciones: perms::add_perms o perms::remove_perms.

Si mask & perms::add_perms, las funciones establecen los permisos en status(pval).permissions() | mask & perms::mask. En caso contrario, si mask & perms::remove_perms, las funciones establecen los permisos en status(pval).permissions() & ~(mask & perms::mask). En caso contrario, las funciones establecen los permisos en mask & perms::mask.

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);

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);

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(const path& pval, uintmax_t size);
void resize(const path& pval, uintmax_t size, error_code& ec) noexcept;

Las funciones modifican el tamaño de un archivo de tal modo 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.

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.

system_complete

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

Las funciones devuelven un nombre de ruta de acceso absoluta que tiene en cuenta, según sea necesario, el directorio actual asociado a su nombre de raíz. (Para POSIX, las funciones devuelven absolute(pval)).

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);