Namespaces
Variants

std::filesystem:: file_type

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
Definido en el encabezado <filesystem>
enum class file_type {

none = /* unspecified */ ,
not_found = /* unspecified */ ,
regular = /* unspecified */ ,
directory = /* unspecified */ ,
symlink = /* unspecified */ ,
block = /* unspecified */ ,
character = /* unspecified */ ,
fifo = /* unspecified */ ,
socket = /* unspecified */ ,
unknown = /* unspecified */ ,
/* implementation-defined */

} ;
(desde C++17)

file_type define constantes que indican el tipo de archivo o directorio al que se refiere una ruta. Los valores de los enumeradores son distintos.

Constantes

Enumerador Significado
none indica que el estado del archivo no ha sido evaluado aún, o ocurrió un error al evaluarlo
not_found indica que el archivo no fue encontrado (esto no se considera un error)
regular un archivo regular
directory un directorio
symlink un enlace simbólico
block un archivo especial de bloque
character un archivo especial de carácter
fifo un archivo FIFO (también conocido como pipe)
socket un archivo socket
unknown el archivo existe pero su tipo no pudo ser determinado
implementation-defined una constante adicional definida por la implementación para cada tipo de archivo adicional soportado por la implementación (por ejemplo, MSVC STL define junction para uniones NTFS )

Ejemplo

Ejecutar este código 
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>
namespace fs = std::filesystem;
void demo_status(const fs::path& p, fs::file_status s)
{
    std::cout << p;
    switch (s.type())
    {
        case fs::file_type::ninguno:
            std::cout << " tiene tipo `not-evaluated-yet`";
            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::directorio:
            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 de bloque";
            break;
        case fs::file_type::carácter:
            std::cout << " es un dispositivo de caracteres";
            break;
        case fs::file_type::fifo:
            std::cout << " es una tubería IPC con nombre";
            break;
        case fs::file_type::socket:
            std::cout << " es un socket IPC con nombre";
            break;
        case fs::file_type::unknown:
            std::cout << " tiene tipo `unknown`";
            break;
        default:
            std::cout << " tiene tipo `implementation-defined`";
            break;
    }
    std::cout << '\n';
}
int main()
{
    // crear archivos de diferentes tipos
    fs::create_directory("sandbox");
    fs::create_directory("sandbox/dir");
    std::ofstream{"sandbox/file"}; // crear archivo regular
    fs::create_symlink("archivo", "sandbox/symlink");
    mkfifo("sandbox/pipe", 0644);
    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, reinterpret_cast<sockaddr*>(&addr), sizeof addr);
    // demo different status accessors
    for (auto it{fs::directory_iterator("sandbox")}; it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // usar estado en caché de la entrada del directorio
    demo_status("/dev/null", fs::estado("/dev/null")); // llamadas directas a status
    demo_status("/dev/sda", fs::estado("/dev/sda"));
    demo_status("sandbox/no", fs::estado("/sandbox/no"));
    // limpieza (preferir eliminadores personalizados basados en std::unique_ptr)
    close(fd);
    fs::remove_all("sandbox");
}

Salida posible: 

"sandbox/file" es un archivo regular
"sandbox/dir" es un directorio
"sandbox/pipe" es una named IPC pipe
"sandbox/sock" es una named IPC socket
"sandbox/symlink" es un enlace simbólico
"/dev/null" es un dispositivo de caracteres
"/dev/sda" es un dispositivo de bloque
"sandbox/no" no existe

Véase también

(C++17)
representa el tipo de archivo y permisos
(clase)
(C++17)
comprueba si la ruta dada se refiere a un dispositivo de bloques
(función)
(C++17)
comprueba si la ruta dada se refiere a un dispositivo de caracteres
(función)
(C++17)
comprueba si la ruta dada se refiere a un directorio
(función)
(C++17)
comprueba si la ruta dada se refiere a una tubería con nombre
(función)
(C++17)
comprueba si el argumento se refiere a un archivo otro
(función)
(C++17)
comprueba si el argumento se refiere a un socket IPC con nombre
(función)
(C++17)
comprueba si el argumento se refiere a un enlace simbólico
(función)
comprueba si la entrada de directorio se refiere a un archivo regular
(función miembro pública de std::filesystem::directory_entry )