Namespaces
Variants

std::filesystem::directory_entry:: status, std::filesystem::directory_entry:: symlink_status

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
std::filesystem::directory_entry
Member functions
Modifiers
Observers
directory_entry::status directory_entry::symlink_status
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
Non-member functions
(1) (seit C++17)
(2) (seit C++17)
std:: filesystem :: file_status symlink_status ( ) const ;
(3) (seit C++17)
std:: filesystem :: file_status symlink_status ( std:: error_code & ec ) const noexcept ;
(4) (seit C++17)
1,2) Gibt den Status des Eintrags zurück, wie durch einen filesystem::status Aufruf bestimmt (Symlinks werden zu ihren Zielen verfolgt).
3,4) Gibt den Status des Eintrags zurück, wie durch einen filesystem::symlink_status Aufruf bestimmt (Symlinks werden nicht verfolgt).

Inhaltsverzeichnis

Parameter

ec - Out-Parameter für Fehlerberichterstattung in der nicht-werfenden Überladung

Rückgabewert

Der Status der durch den Eintrag referenzierten Datei.

Ausnahmen

Jede Überladung, die nicht als noexcept gekennzeichnet ist, kann std::bad_alloc werfen, wenn die Speicherallokation fehlschlägt.

1,3) Wirft std::filesystem::filesystem_error bei zugrundeliegenden OS-API-Fehlern, konstruiert mit p als erstem Pfadargument und dem OS-Fehlercode als Fehlercodeargument.
2,4) Setzt einen std:: error_code & -Parameter auf den OS-API-Fehlercode, falls ein OS-API-Aufruf fehlschlägt, und führt ec. clear ( ) aus, falls keine Fehler auftreten.

Hinweise

Viele Low-Level-Betriebssystem-APIs für das Durchlaufen von Verzeichnissen rufen Dateiattribute zusammen mit dem nächsten Verzeichniseintrag ab. Die Konstruktoren und die nicht-konstanten Memberfunktionen von std::filesystem::directory_iterator speichern diese Attribute, falls vorhanden, im referenzierten std::filesystem::directory_entry , ohne directory_entry::refresh aufzurufen. Dies ermöglicht die Überprüfung der Attribute der Verzeichniseinträge während der Iteration, ohne zusätzliche Systemaufrufe durchführen zu müssen.

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;
    // alternative: switch(s.type()) { case fs::file_type::regular: ...}
    if (fs::is_regular_file(s))
        std::cout << " ist eine reguläre Datei\n";
    if (fs::is_directory(s))
        std::cout << " ist ein Verzeichnis\n";
    if (fs::is_block_file(s))
        std::cout << " ist ein Blockgerät\n";
    if (fs::is_character_file(s))
        std::cout << " ist ein Zeichengerät\n";
    if (fs::is_fifo(s))
        std::cout << " ist eine benannte IPC-Pipe\n";
    if (fs::is_socket(s))
        std::cout << " ist ein benannter IPC-Socket\n";
    if (fs::is_symlink(s))
        std::cout << " ist ein Symlink\n";
    if (!fs::exists(s))
        std::cout << " existiert nicht\n";
}
int main()
{
    // Erstellen von Dateien verschiedener Arten
    fs::create_directory("sandbox");
    fs::create_directory("sandbox/dir");
    std::ofstream{"sandbox/file"}; // reguläre Datei erstellen
    fs::create_symlink("file", "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);
    // Demonstration verschiedener Statuszugriffsmethoden
    for (auto it{fs::directory_iterator("sandbox")}; it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // verwendung des zwischengespeicherten Status aus dem Verzeichniseintrag
    demo_status("/dev/null", fs::status("/dev/null")); // direkte Aufrufe von status
    demo_status("/dev/sda", fs::status("/dev/sda"));
    demo_status("sandbox/no", fs::status("/sandbox/no"));
    // Bereinigung (bevorzuge std::unique_ptr-basierte benutzerdefinierte Löscher)
    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

aktualisiert die zwischengespeicherten Dateiattribute
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf ein existierendes Dateisystemobjekt verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf ein Blockgerät verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf ein Zeichengerät verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf ein Verzeichnis verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf eine benannte Pipe verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf eine andere Datei verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf eine reguläre Datei verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf einen benannten IPC-Socket verweist
(öffentliche Elementfunktion)
prüft, ob der Verzeichniseintrag auf einen symbolischen Link verweist
(öffentliche Elementfunktion)
gibt die Größe der Datei zurück, auf die der Verzeichniseintrag verweist
(öffentliche Elementfunktion)
gibt die Anzahl der Hardlinks zurück, die auf die Datei verweisen, auf die der Verzeichniseintrag verweist
(öffentliche Elementfunktion)
ruft den Zeitpunkt der letzten Datenänderung der Datei ab, auf die der Verzeichniseintrag verweist
(öffentliche Elementfunktion)