std::filesystem::directory_entry::status, std::filesystem::directory_entry::symlink_status
std::filesystem::file_status status() const; std::filesystem::file_status status( std::error_code& ec ) const noexcept; |
(1) | (desde C++17) |
std::filesystem::file_status symlink_status() const; std::filesystem::file_status symlink_status( std::error_code& ec ) const noexcept; |
(2) | (desde C++17) |
Parámetros
| ec | - | El parámetro de salida para informe de errores en la sobrecarga que no lanza excepciones. |
Valor de retorno
El estado del archivo al que hace referencia la entrada de directorio.
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.
Notas
Muchas API de bajo nivel del sistema operativo para el recorrido de directorios recuperan atributos de archivo junto con la siguiente entrada de directorio. Los constructores y las funciones miembro no const de std::filesystem::directory_iterator almacenan estos atributos, si los hay, en el objeto std::filesystem::directory_entry al que se apunta sin llamar a directory_entry::refresh, lo que permite examinar los atributos de las entradas de directorio a medida que se recorren, sin realizar llamadas adicionales al sistema.
Ejemplo
#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
Véase también
| Actualiza los atributos del archivo en caché. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un objeto existente en el sistema de archivos. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un dispositivo orientado a bloques. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un dispositivo orientado a caracteres. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un directorio. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un pipe denominado. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a otro archivo. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un archivo regular. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un socket IPC denominado. (función miembro pública) | |
| Verifica si la entrada de directorio se refiere a un enlace simbólico. (función miembro pública) | |
| Devuelve el tamaño del archivo al que se refiere la entrada de directorio. (función miembro pública) | |
| Devuelve el número de enlaces físicos que se refieren al archivo al que se refiere la entrada de directorio. (función miembro pública) | |
| Obtiene o establece la fecha y la hora de la última modificación de datos del archivo al que se refiere la entrada de directorio. (función miembro pública) |