Namespaces
Variants

std::filesystem::directory_entry:: status, std::filesystem::directory_entry:: symlink_status

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
std::filesystem::directory_entry
Member functions
Modifiers
Observers
directory_entry::status directory_entry::symlink_status
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
Non-member functions
(1) (desde C++17)
(2) (desde C++17)
std:: filesystem :: file_status symlink_status ( ) const ;
(3) (desde C++17)
std:: filesystem :: file_status symlink_status ( std:: error_code & ec ) const noexcept ;
(4) (desde C++17)
1,2) Devuelve el estado de la entrada, como si fuera determinado por una llamada a filesystem::status (los enlaces simbólicos se siguen hasta sus destinos).
3,4) Devuelve el estado de la entrada, como si fuera determinado por una llamada a filesystem::symlink_status (los enlaces simbólicos no se siguen).

Contenidos

Parámetros

ec - parámetro de salida para reporte de errores en la sobrecarga que no lanza excepciones

Valor de retorno

El estado del archivo referenciado por la entrada.

Excepciones

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

1,3) Lanza std::filesystem::filesystem_error en errores de la API del sistema operativo subyacente, construido con p como primer argumento de ruta y el código de error del sistema operativo como argumento de código de error.
2,4) Establece un parámetro std:: error_code & al código de error de la API del sistema operativo si una llamada a la API del SO falla, y ejecuta ec. clear ( ) si no ocurren errores.

Notas

Muchas APIs de bajo nivel del sistema operativo para recorrido de directorios recuperan atributos de archivo junto con la siguiente entrada del directorio. Los constructores y las funciones miembro no constantes de std::filesystem::directory_iterator almacenan estos atributos, si los hay, en el std::filesystem::directory_entry apuntado sin llamar a directory_entry::refresh , lo que hace posible examinar los atributos de las entradas del directorio mientras se están iterando, sin realizar llamadas adicionales al sistema.

Ejemplo

Ejecutar este código 
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>
namespace fs = std::filesystem;
void demo_status(const fs::path& p, fs::file_status s)
{
    std::cout << p;
    // alternativa: switch(s.type()) { case fs::file_type::regular: ...}
    if (fs::is_regular_file(s))
        std::cout << " is a regular file\n";
    if (fs::is_directory(s))
        std::cout << " is a directory\n";
    if (fs::is_block_file(s))
        std::cout << " is a block device\n";
    if (fs::is_character_file(s))
        std::cout << " is a character device\n";
    if (fs::is_fifo(s))
        std::cout << " is a named IPC pipe\n";
    if (fs::is_socket(s))
        std::cout << " is a named IPC socket\n";
    if (fs::is_symlink(s))
        std::cout << " is a symlink\n";
    if (!fs::exists(s))
        std::cout << " does not exist\n";
}
int main()
{
    // crear archivos de diferentes tipos
    fs::create_directory("sandbox");
    fs::create_directory("sandbox/dir");
    std::ofstream{"sandbox/file"}; // crear archivo regular
    fs::create_symlink("file", "sandbox/symlink");
    mkfifo("sandbox/pipe", 0644);
    sockaddr_un addr;
    addr.sun_family = AF_UNIX;
    std::strcpy(addr.sun_path, "sandbox/sock");
    int fd = socket(PF_UNIX, SOCK_STREAM, 0);
    bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof addr);
    // demostrar diferentes accesores de estado
    for (auto it{fs::directory_iterator("sandbox")}; it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // usar estado en caché de la entrada del directorio
    demo_status("/dev/null", fs::status("/dev/null")); // llamadas directas a status
    demo_status("/dev/sda", fs::status("/dev/sda"));
    demo_status("sandbox/no", fs::status("/sandbox/no"));
    // limpieza (preferir eliminadores personalizados basados en std::unique_ptr)
    close(fd);
    fs::remove_all("sandbox");
}

Salida posible: 

"sandbox/file" is a regular file
"sandbox/dir" is a directory
"sandbox/pipe" is a named IPC pipe
"sandbox/sock" is a named IPC socket
"sandbox/symlink" is a symlink
"/dev/null" is a character device
"/dev/sda" is a block device
"sandbox/no" does not exist

Véase también

actualiza los atributos de archivo en caché
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un objeto del sistema de archivos existente
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un dispositivo de bloques
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un dispositivo de caracteres
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un directorio
(función de miembro pública)
verifica si la entrada de directorio hace referencia a una tubería con nombre
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un archivo otro
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un archivo regular
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un socket IPC con nombre
(función de miembro pública)
verifica si la entrada de directorio hace referencia a un enlace simbólico
(función de miembro pública)
devuelve el tamaño del archivo al que hace referencia la entrada de directorio
(función de miembro pública)
devuelve el número de enlaces físicos que hacen referencia al archivo al que apunta la entrada de directorio
(función de miembro pública)
obtiene el tiempo de la última modificación de datos del archivo al que hace referencia la entrada de directorio
(función de miembro pública)