std::filesystem::is_directory
De cppreference.com
< cpp | filesystem
<tbody>
</tbody>
| Definido en el archivo de encabezado <filesystem>
|
||
bool is_directory( std::filesystem::file_status s ) noexcept; |
(1) | (desde C++17) |
bool is_directory( const std::filesystem::path& p ); bool is_directory( const std::filesystem::path& p, std::error_code& ec ) noexcept; |
(2) | (desde C++17) |
Verifica si el estado de archivo dado o la ruta de acceso dada corresponde a un directorio.
1) Equivalente a
s.type() == file_type::directory.2) Equivalente a
is_directory(status(p)) o is_directory(status(p, ec)), respectivamente.Parámetros
| s | - | El estado de archivo a verificar. |
| p | - | La ruta de acceso a examinar. |
| ec | - | El código de error a modificar en caso de error. |
Valor de retorno
true si el archivo indicado por p o si el tipo indicado s se refieren a un directorio, false de lo contrario. La sobrecarga que no lanza devuelve false si ocurre un error.
Excepciones
2) 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.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
Véase también
(C++17)(C++17) |
Determina los atributos de archivo. Determina los atributos de archivo, verificando el objetivo del enlace simbólico. (función) |
(C++17) |
Representa el tipo y permisos de archivo. (clase) |
(C++17) |
Verifica si se conoce el estado de archivo. (función) |
(C++17) |
Verifica si una ruta de acceso dada se refiere a un dispositivo de bloques. (función) |
(C++17) |
Verifica si la ruta de acceso dada se refiere a un dispositivo de caracteres. (función) |
(C++17) |
Verifica si la ruta de acceso dada se refiere a una tubería con nombre (named pipe). (función) |
(C++17) |
Verifica si el argumento se refiere a "otro" tipo de archivo. (función) |
(C++17) |
Verifica si el argumento se refiere a un archivo regular. (función) |
(C++17) |
Verifica si el argumento se refiere a un socket de comunicación interproceso con nombre. (función) |
(C++17) |
Verifica si el argumento se refiere a un enlace simbólico. (función) |
(C++17) |
Verifica si una ruta de acceso se refiere a un objeto existente del sistema de archivos. (función) |
| Verifica si la entrada de directorio se refiere a un directorio. (función miembro pública de std::filesystem::directory_entry)
|