Namespaces
Variants

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

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
directory_entry
file_status status ( ) const ;
file_status status ( error_code & ec ) const ;
(1) (filesystem TS)
file_status symlink_status ( ) const ;
file_status symlink_status ( error_code & ec ) const ;
(2) (filesystem TS)
1) Devuelve el estado potencialmente almacenado en caché de la entrada, como si fuera determinado por una llamada status (los enlaces simbólicos se siguen hasta sus destinos).
2) Devuelve el estado potencialmente almacenado en caché de la entrada, como si fuera determinado por una llamada a 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

The overload that does not take an error_code & parameter throws filesystem_error on underlying OS API errors, constructed with p as the first argument and the OS error code as the error code argument. std:: bad_alloc may be thrown if memory allocation fails. The overload taking an error_code & parameter sets it to the OS API error code if an OS API call fails, and executes ec. clear ( ) if no errors occur. This overload has
noexcept especificación:
noexcept

Notas

La información de estado del archivo generalmente se proporciona como un subproducto de la iteración de directorios, en cuyo caso se almacena en caché y puede obtenerse mediante estas funciones miembro sin el costo de una llamada adicional al sistema. Durante la iteración de directorios, llamar a status es innecesario y los accesores como is_directory deben llamarse con el valor de estado en caché, no con una ruta.

Ejemplo

Ejecutar este código 
#include <cstdio>
#include <cstring>
#include <experimental/filesystem>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>
namespace fs = std::experimental::filesystem;
void demo_status(const fs::path& p, fs::file_status s)
{
    std::cout << p;
    // alternative: 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()
{
    // create files of different kinds
    fs::create_directory("sandbox");
    std::ofstream("sandbox/file"); // create regular file
    fs::create_directory("sandbox/dir");
    mkfifo("sandbox/pipe", 0644);
    struct 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, (struct sockaddr*)&addr, sizeof addr);
    fs::create_symlink("file", "sandbox/symlink");
    // demo different status accessors
    for (auto it = fs::directory_iterator("sandbox"); it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // use cached status from directory entry
    demo_status("dev/null", fs::status("/dev/null")); // direct calls to status
    demo_status("dev/sda", fs::status("/dev/sda"));
    demo_status("sandbox/no", fs::status("/sandbox/no"));
    // cleanup
    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

representa el tipo de archivo y permisos
(clase)
determina los atributos del archivo
determina los atributos del archivo, verificando el destino del enlace simbólico
(función)
verifica si el estado del archivo es conocido
(función)
verifica si la ruta dada se refiere a un dispositivo de bloque
(función)
verifica si la ruta dada se refiere a un dispositivo de caracteres
(función)
verifica si la ruta dada se refiere a un directorio
(función)
verifica si la ruta dada se refiere a una tubería con nombre
(función)
verifica si el argumento se refiere a un archivo otro
(función)
verifica si el argumento se refiere a un archivo regular
(función)
verifica si el argumento se refiere a un socket IPC con nombre
(función)
verifica si el argumento se refiere a un enlace simbólico
(función)