Namespaces
Variants

std::filesystem:: file_type

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
Défini dans l'en-tête <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 */

} ;
(depuis C++17)

file_type définit des constantes qui indiquent le type d'un fichier ou d'un répertoire auquel un chemin fait référence. Les valeurs des énumérateurs sont distinctes.

Constantes

Énumérateur Signification
none indique que le statut du fichier n'a pas encore été évalué, ou qu'une erreur s'est produite lors de son évaluation
not_found indique que le fichier n'a pas été trouvé (ceci n'est pas considéré comme une erreur)
regular un fichier régulier
directory un répertoire
symlink un lien symbolique
block un fichier spécial de type bloc
character un fichier spécial de type caractère
fifo un fichier FIFO (également appelé tube)
socket un fichier de socket
unknown le fichier existe mais son type n'a pas pu être déterminé
implementation-defined une constante supplémentaire définie par l'implémentation pour chaque type de fichier supplémentaire pris en charge par l'implémentation (par exemple, MSVC STL définit junction pour les jonctions NTFS )

Exemple

Exécuter ce code 
#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::aucun:
            std::cout << " a le type `not-evaluated-yet`";
            break;
        case fs::file_type::not_found:
            std::cout << " n'existe pas";
            break;
        case fs::file_type::régulier:
            std::cout << " est un fichier régulier";
            break;
        case fs::file_type::répertoire:
            std::cout << " est un répertoire";
            break;
        case fs::file_type::symlink:
            std::cout << " est un lien symbolique";
            break;
        case fs::file_type::bloc:
            std::cout << " est un périphérique de bloc";
            break;
        case fs::file_type::caractère:
            std::cout << " est un périphérique caractère";
            break;
        case fs::file_type::fifo:
            std::cout << " est un canal IPC nommé";
            break;
        case fs::file_type::socket:
            std::cout << " est un socket IPC nommé";
            break;
        case fs::file_type::inconnu:
            std::cout << " a un type `unknown`";
            break;
        default:
            std::cout << " a un type `implementation-defined`";
            break;
    }
    std::cout << '\n';
}
int main()
{
    // créer des fichiers de différents types
    fs::create_directory("bac à sable");
    fs::create_directory("bac à sable/répertoire");
    std::ofstream{"sandbox/file"}; // créer un fichier régulier
    fs::create_symlink("fichier", "bac à sable/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);
    // démontrer les différents accesseurs de statut
    for (auto it{fs::directory_iterator("bac à sable")}; it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // utiliser le statut mis en cache depuis l'entrée du répertoire
    demo_status("/dev/null", fs::statut("/dev/null")); // appels directs au statut
    demo_status("/dev/sda", fs::statut("/dev/sda"));
    demo_status("sandbox/no", fs::statut("/sandbox/no"));
    // nettoyage (préférer les suppresseurs personnalisés basés sur std::unique_ptr)
    close(fd);
    fs::remove_all("bac à sable");
}

Sortie possible : 

"sandbox/file" est un fichier régulier
"sandbox/dir" est un répertoire
"sandbox/pipe" est un tube IPC nommé
"sandbox/sock" est un socket IPC nommé
"sandbox/symlink" est un lien symbolique
"/dev/null" est un périphérique caractère
"/dev/sda" est un périphérique bloc
"sandbox/no" n'existe pas

Voir aussi

(C++17)
représente le type de fichier et les permissions
(classe)
(C++17)
vérifie si le chemin donné fait référence à un périphérique bloc
(fonction)
(C++17)
vérifie si le chemin donné fait référence à un périphérique caractère
(fonction)
(C++17)
vérifie si le chemin donné fait référence à un répertoire
(fonction)
(C++17)
vérifie si le chemin donné fait référence à un tube nommé
(fonction)
(C++17)
vérifie si l'argument fait référence à un autre type de fichier
(fonction)
(C++17)
vérifie si l'argument fait référence à une socket IPC nommée
(fonction)
(C++17)
vérifie si l'argument fait référence à un lien symbolique
(fonction)
vérifie si l'entrée de répertoire fait référence à un fichier régulier
(fonction membre publique de std::filesystem::directory_entry )