Espacios de nombres
Variantes
Acciones

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

De cppreference.com
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Biblioteca del sistema de archivos
Clases
Funciones
Tipos de archivo
 
Definido en el archivo de encabezado <filesystem>
std::filesystem::file_status status( const std::filesystem::path& p );

std::filesystem::file_status status( const std::filesystem::path& p,

                                     std::error_code& ec ) noexcept;
 (1) (desde C++17)
std::filesystem::file_status symlink_status( const std::filesystem::path& p );

std::filesystem::file_status symlink_status( const std::filesystem::path& p,

                                             std::error_code& ec ) noexcept;
 (2) (desde C++17)
1) Determina el tipo y atributos del objeto del sistema de archivos identificado por p como si fuera por la función stat de POSIX (los enlaces simbólicos se siguen a sus objetivos). En la siguiente descripción, prms es el resultado de (m & perms::mask), donde m se obtiene como si se tomara st_mode de la función struct stat de POSIX y se convirtiera al tipo std::filesystem::perms.
  • Si p es un archivo regular (como si fuera por POSIX S_ISREG), devuelve file_status(file_type::regular, prms).
  • Si p es un directorio (como si fuera por POSIX S_ISDIR), devuelve file_status(file_type::directory, prms).
  • Si p es un archivo especial orientado a bloques (como si fuera por POSIX S_ISBLK), devuelve file_status(file_type::block, prms).
  • Si p es un archivo especial orientado a caracteres (como si fuera por POSIX S_ISCHR), devuelve file_status(file_type::character, prms).
  • Si p es un archivo FIFO o de tubería (pipe) (como si fuera por POSIX S_ISFIFO), devuelve file_status(file_type::fifo, prms).
  • Si p es un socket (como si fuera por POSIX S_ISSOCK), devuelve file_status(file_type::socket, prms).
  • Si p tiene un tipo de archivo definido por la implementación, devuelve file_status(file_type::A, prms) donde A es la consgtante file_type definida por la implementación para ese tipo.
  • Si p no existe, devuelve file_status(file_type::not_found) .
  • Si p existe pero los atributos de archivo no pueden determinarse, por ejemplo, debido a falta de permisos, devuelve file_status(file_type::unknown).
  • Si errores impiden incluso saber si p existe, la sobrecarga que no lanzan excepciones establece ec y devuelve file_status(file_type::none), y la sobrecarga que lanza excepciones lanza filesystem_error.
  • De lo contrario, devuelve file_status(file_type::unknown, prms).
2) Igual que (1) excepto que el comportamiento es como si se usara la función lstat de POSIX (no se siguen los enlaces simbólicos):
  • Si p es un enlace simbólico, devuelve file_status(file_type::symlink).

Contenido

[editar] Parámetros

p - La ruta de acceso a examinar.
ec - El parámetro de salida para informe de errores en la sobrecarga que no lanza.

[editar] Valor de retorno

El estado de archivo (un objeto filesystem::file_status).

[editar] Excepciones

La sobrecarga que no toma un parámetro std::error_code& lanza filesystem::filesystem_error en los errores de la API del sistema operativo subyacente, construido con p como el primer argumento de la ruta de acceso y el c��digo de error del sistema operativo como el argumento del código de error. La sobrecarga que toma un parámetro std::error_code& lo establece en el código de error de la API del sistema operativo si una llamada a la API del sistema operativo falla, y ejecuta ec.clear() si no ocurren errores. Cualquier sobrecarga que no está marcada con noexcept puede lanzar std::bad_alloc si la asignación de memoria falla.

[editar] Notas

La información proporcionada por esta función generalmente también se proporciona como un subproducto de la iteración del directorio, y puede ser obtenida por las funciones miembro de filesystem::directory_entry. Durante la iteración del directorio, llamar a status de nuevo es innecesario.

[editar] Ejemplo

Ejecuta este código
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
 
namespace fs = std::filesystem;
 
void demo_estado(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 << " es un archivo regular\n";
    if(fs::is_directory(s)) std::cout << " es un directorio\n";
    if(fs::is_block_file(s)) std::cout << " es un dispositivo orientado a bloques\n";
    if(fs::is_character_file(s)) std::cout << " es un dispositivo orientado a caracteres\n";
    if(fs::is_fifo(s)) std::cout << " es un pipe IPC denominado\n";
    if(fs::is_socket(s)) std::cout << " es un socket IPC denominado\n";
    if(fs::is_symlink(s)) std::cout << " es un enlace simbólico\n";
    if(!fs::exists(s)) std::cout << " no existe\n";
}
 
int main()
{
    // crear archivos de distintos tipos en un entorno aislado
    fs::create_directory("entorno_aislado");
    std::ofstream("entorno_aislado/archivo"); // crear archivo regular
    fs::create_directory("entorno_aislado/dir");
    mkfifo("entorno_aislado/pipe", 0644);
    sockaddr_un addr;
    addr.sun_family = AF_UNIX;
    std::strcpy(addr.sun_path, "entorno_aislado/sock");
    int fd = socket(PF_UNIX, SOCK_STREAM, 0);
    bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof addr);
    fs::create_symlink("archivo", "entorno_aislado/enlace");
 
    // demostrar diferentes accesores de estado
    for(auto it = fs::directory_iterator("entorno_aislado"); it != fs::directory_iterator(); ++it)
        demo_estado(*it, it->symlink_status()); // usar estado en la caché de la entrada de directorio
    demo_estado("/dev/null", fs::status("/dev/null")); // llamadas directas a estado
    demo_estado("/dev/sda", fs::status("/dev/sda"));
    demo_estado("entorno_aislado/no", fs::status("/entorno_aislado/no"));
 
    // limpieza
    close(fd);
    fs::remove_all("entorno_aislado");
}

Posible salida: 

"entorno_aislado/archivo" es un archivo regular
"entorno_aislado/dir" es un directorio
"entorno_aislado/pipe" es un pipe IPC denominado
"entorno_aislado/sock" es un socket IPC denominado
"entorno_aislado/enlace" es un enlace simbólico
"/dev/null" es un dispositivo orientado a caracteres
"/dev/sda" es un dispositivo orientado a bloques
"entorno_aislado/no" no existe

[editar] Véase también

(C++17)
 Representa el tipo y permisos de archivo.
(clase) [editar]
(C++17)
 Verifica si se conoce el estado de archivo.
(función) [editar]
(C++17)
 Verifica si una ruta de acceso dada se refiere a un dispositivo de bloques.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a un dispositivo de caracteres.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a un directorio.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a una tubería con nombre (named pipe).
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a "otro" tipo de archivo.
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a un archivo regular.
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a un socket de comunicación interproceso con nombre.
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a un enlace simbólico.
(función) [editar]
(C++17)
 Verifica si una ruta de acceso se refiere a un objeto existente del sistema de archivos.
(función) [editar]
Estado del archivo designado por esta entrada de directorio.
symlink_status del archivo designado por esta entrada de directorio.
(función miembro pública de std::filesystem::directory_entry) [editar]
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/filesystem/status&oldid=40211»