std::filesystem::file_type
De cppreference.com
< cpp | filesystem
<tbody>
</tbody>
| Definido en el archivo de encabezado <filesystem>
|
||
enum class file_type { none = /* no especificado */, not_found = /* no especificado */, regular = /* no especificado */, directory = /* no especificado */, symlink = /* no especificado */, block = /* no especificado */, character = /* no especificado */, fifo = /* no especificado */, socket = /* no especificado */, unknown = /* no especificado */, /* definido-por-la-implementación */ }; |
(desde C++17) | |
file_type define constantes que indican el tipo de un archivo o directorio al que se refiere una ruta de acceso. Los valores los enumeradores son distintos.
Indica que el archivo no se encontró (esto no se considera un error)
Constantes
| Constante | Significado |
none
|
Indica que el estado del archivo aún no se ha evaluado, o se produjo un error al evaluarlo. |
not_found
|
Indica que el archivo no se encontró (esto no se considera un error) |
regular
|
Un archivo regular. |
directory
|
Un directorio |
symlink
|
Un enlace simbólico. |
block
|
Un archivo especial orientado a bloques. |
character
|
Un archivo especial orientado a caracteres. |
fifo
|
Un archivo FIFO (también conocido como tubería). |
socket
|
Un archivo socket. |
| definido-por-la-implementación | Una constante adicional definida por la implementación para cada tipo de archivo adicional apoyado por la implementación (por ejemplo MSVC STL define junction para las uniones de NTFS)
|
unknown
|
El archivo existe pero no se pudo determinar su tipo. |
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;
switch(s.type())
{
case fs::file_type::none: std::cout << " tiene tipo `no evaluado`"; break;
case fs::file_type::not_found: std::cout << " no existe"; break;
case fs::file_type::regular: std::cout << " es un archivo regular"; break;
case fs::file_type::directory: std::cout << " es un directorio"; break;
case fs::file_type::symlink: std::cout << " es un enlace simbólico"; break;
case fs::file_type::block: std::cout << " es un dispositivo orientado a bloques"; break;
case fs::file_type::character: std::cout << " es un dispositivo orientado a caracteres"; break;
case fs::file_type::fifo: std::cout << " es un pipe IPC denominado"; break;
case fs::file_type::socket: std::cout << " es un socket IPC denominado"; break;
case fs::file_type::unknown: std::cout << " tiene un tipo `desconocido`"; break;
default: std::cout << " tiene un tipo `definido por la implementación`"; break;
}
std::cout << '\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) |
Representa el tipo y permisos de archivo. (clase) |
(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 un directorio. (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 socket de comunicación interproceso con nombre. (función) |
(C++17) |
Verifica si el argumento se refiere a un enlace simbólico. (función) |
| Verifica si la entrada de directorio se refiere a un archivo regular. (función miembro pública de std::filesystem::directory_entry)
|