Namespaces
Variants

std::filesystem:: file_type

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
Definiert in Header <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 */

} ;
(seit C++17)

file_type definiert Konstanten, die den Typ einer Datei oder eines Verzeichnisses angeben, auf den ein Pfad verweist. Die Werte der Enumeratoren sind eindeutig.

Konstanten

Enumerator Bedeutung
none zeigt an, dass der Dateistatus noch nicht ausgewertet wurde oder bei der Auswertung ein Fehler aufgetreten ist
not_found zeigt an, dass die Datei nicht gefunden wurde (dies wird nicht als Fehler betrachtet)
regular eine reguläre Datei
directory ein Verzeichnis
symlink eine symbolische Verknüpfung
block eine blockorientierte Spezialdatei
character eine zeichenorientierte Spezialdatei
fifo eine FIFO-Datei (auch als Pipe bekannt)
socket eine Socket-Datei
unknown die Datei existiert, aber ihr Typ konnte nicht bestimmt werden
implementation-defined eine zusätzliche implementierungsdefinierte Konstante für jeden zusätzlichen Dateityp, der von der Implementierung unterstützt wird (z.B. definiert MSVC STL junction für NTFS-Junctions )

Beispiel

Diesen Code ausführen 
#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::none:
            std::cout << " hat den Typ `not-evaluated-yet`";
            break;
        case fs::file_type::not_found:
            std::cout << " existiert nicht";
            break;
        case fs::file_type::regulär:
            std::cout << " ist eine reguläre Datei";
            break;
        case fs::file_type::Verzeichnis:
            std::cout << " ist ein Verzeichnis";
            break;
        case fs::file_type::symlink:
            std::cout << " ist eine symbolische Verknüpfung";
            break;
        case fs::file_type::Block:
            std::cout << " ist ein Blockgerät";
            break;
        case fs::file_type::Zeichen:
            std::cout << " ist ein Zeichengerät";
            break;
        case fs::file_type::fifo:
            std::cout << " ist ein benannter IPC-Pipe";
            break;
        case fs::file_type::socket:
            std::cout << " ist ein benannter IPC-Socket";
            break;
        case fs::file_type::unknown:
            std::cout << " hat Typ `unknown`";
            break;
        default:
            std::cout << " hat `implementation-defined` Typ";
            break;
    }
    std::cout << '\n';
}
int main()
{
    // Dateien verschiedener Arten erstellen
    fs::create_directory("Sandbox");
    fs::create_directory("sandbox/dir");
    std::ofstream{"sandbox/file"}; // reguläre Datei erstellen
    fs::create_symlink("Datei", "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);
    // verschiedene Status-Accessoren demonstrieren
    for (auto it{fs::directory_iterator("Sandbox")}; it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // verwenden Sie den zwischengespeicherten Status aus dem Verzeichniseintrag
    demo_status("/dev/null", fs::Status("/dev/null")); // direkte Aufrufe des Status
    demo_status("/dev/sda", fs::Status("/dev/sda"));
    demo_status("sandbox/nein", fs::Status("/sandbox/nein"));
    // Bereinigung (bevorzuge std::unique_ptr-basierte benutzerdefinierte Deleter)
    close(fd);
    fs::remove_all("Sandbox");
}

Mögliche Ausgabe: 

"sandbox/file" ist eine reguläre Datei
"sandbox/dir" ist ein Verzeichnis
"sandbox/pipe" ist eine benannte IPC-Pipe
"sandbox/sock" ist ein benannter IPC-Socket
"sandbox/symlink" ist ein Symlink
"/dev/null" ist ein Zeichengerät
"/dev/sda" ist ein Blockgerät
"sandbox/no" existiert nicht

Siehe auch

(C++17)
repräsentiert Dateityp und Berechtigungen
(Klasse)
(C++17)
prüft, ob der angegebene Pfad auf ein Blockgerät verweist
(Funktion)
(C++17)
prüft, ob der angegebene Pfad auf ein Zeichengerät verweist
(Funktion)
(C++17)
prüft, ob der angegebene Pfad auf ein Verzeichnis verweist
(Funktion)
(C++17)
prüft, ob der angegebene Pfad auf eine benannte Pipe verweist
(Funktion)
(C++17)
prüft, ob das Argument auf eine andere Datei verweist
(Funktion)
(C++17)
prüft, ob das Argument auf einen benannten IPC-Socket verweist
(Funktion)
(C++17)
prüft, ob das Argument auf einen symbolischen Link verweist
(Funktion)
prüft, ob der Verzeichniseintrag auf eine reguläre Datei verweist
(öffentliche Elementfunktion von std::filesystem::directory_entry )