Namespaces
Variants

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

From cppreference.net
C++
Experimental
Filesystem library
Classes
Functions
File types
Definido en el encabezado <experimental/filesystem>
file_status status ( const path & p ) ;
file_status status ( const path & p, error_code & ec ) noexcept ;
(1) (filesystem TS)
file_status symlink_status ( const path & p ) ;
file_status symlink_status ( const path & p, error_code & ec ) noexcept ;
(2) (filesystem TS)
1) Determina el tipo y atributos del objeto del sistema de archivos identificado por p como si fuera mediante POSIX stat (los enlaces simbólicos se siguen hasta sus destinos).
  • Si p es un archivo regular, retorna file_status ( file_type :: regular ) .
  • Si p es un directorio, retorna file_status ( file_type :: directory ) .
  • Si p es un archivo especial de bloque, retorna file_status ( file_type :: block ) .
  • Si p es un archivo especial de carácter, retorna file_status ( file_type :: character ) .
  • Si p es un archivo fifo o pipe, retorna file_status ( file_type :: fifo ) .
  • Si p es un socket, retorna file_status ( file_type :: socket ) .
  • Si p no existe, retorna file_status ( file_type :: not_found ) .
  • Si p existe pero no se pueden determinar sus atributos, por ejemplo debido a falta de permisos, retorna file_status ( file_type :: unknown ) .
  • Si errores impiden incluso saber si p existe, la sobrecarga que no lanza excepciones establece ec y retorna file_status ( file_type :: none ) , y la sobrecarga que lanza excepciones lanza filesystem_error .
  • En caso contrario, retorna file_status ( file_type :: unknown ) .
2) Igual que (1) excepto que el comportamiento es como si se usara la función POSIX lstat (los enlaces simbólicos no se siguen):
  • Si p es un enlace simbólico, retorna file_status ( file_type :: symlink ) .

Contenidos

Parámetros

p - ruta a examinar
ec - parámetro de salida para reporte de errores en la sobrecarga no lanzadora

Valor de retorno

El estado del archivo (un file_status objeto).

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 proporcionada por esta función generalmente también se proporciona como un subproducto de la iteración de directorios, y puede obtenerse mediante las funciones miembro de directory_entry . Durante la iteración de directorios, llamar status nuevamente es innecesario.

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)
verifica si el estado del archivo es conocido
(función)
verifica si la ruta dada se refiere a un dispositivo de bloques
(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)
verifica si la ruta se refiere a un objeto del sistema de archivos existente
(función)
estado en caché del archivo designado por esta entrada de directorio
estado de enlace simbólico en caché del archivo designado por esta entrada de directorio
(función miembro pública de std::experimental::filesystem::directory_entry )