Namespaces
Variants

std::experimental::filesystem:: is_block_file

From cppreference.net
C++
Experimental
Filesystem library
Classes
Functions
File types
Definiert im Header <experimental/filesystem>
bool is_block_file ( file_status s ) ;
(1) (filesystem TS)
bool is_block_file ( const path & p ) ;
bool is_block_file ( const path & p, error_code & ec ) noexcept ;
(2) (filesystem TS)

Prüft, ob der angegebene Dateistatus oder Pfad einer blockorientierten Spezialdatei entspricht, wie durch das POSIX- S_ISBLK bestimmt. Beispiele für blockorientierte Spezialdateien sind Blockgeräte wie / dev / sda oder / dev / loop0 unter Linux.

1) Entspricht s. type ( ) == file_type :: block .
2) Entspricht is_block_file ( status ( p ) ) oder is_block_file ( status ( p, ec ) ) .

Inhaltsverzeichnis

Parameter

s - zu prüfender Dateistatus
p - zu untersuchender Pfad
ec - Ausgabeparameter für Fehlerberichterstattung in der nicht-werfenden Überladung

Rückgabewert

true wenn die durch p angegebene Datei oder der durch s angegebene Typ auf ein Blockgerät verweist. Die nicht-werfende Überladung gibt false zurück, wenn ein Fehler auftritt.

Ausnahmen

1)
noexcept Spezifikation:
noexcept
2) Die Überladung, die keinen error_code & Parameter akzeptiert, wirft bei zugrundeliegenden OS-API-Fehlern filesystem_error , konstruiert mit p als erstem Argument und dem OS-Fehlercode als Fehlercode-Argument. std:: bad_alloc kann geworfen werden, wenn die Speicherallokation fehlschlägt. Die Überladung, die einen error_code & Parameter akzeptiert, setzt diesen auf den OS-API-Fehlercode, wenn ein OS-API-Aufruf fehlschlägt, und führt ec. clear ( ) aus, wenn keine Fehler auftreten. Diese Überladung hat
noexcept Spezifikation:
noexcept

Hinweise

Die von dieser Funktion bereitgestellten Informationen werden normalerweise auch als Nebenprodukt der Verzeichnisiteration bereitgestellt. Während der Verzeichnisiteration ist der Aufruf von is_block_file(*iterator) weniger effizient als is_block_file(iterator->status()) .

Beispiel

Diesen Code ausführen 
#include <cstdio>
#include <cstring>
#include <experimental/filesystem>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>
namespace fs = std::experimental::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 verschiedener Dateitypen
    fs::create_directory("sandbox");
    std::ofstream("sandbox/file"); // reguläre Datei erstellen
    fs::create_directory("sandbox/dir");
    mkfifo("sandbox/pipe", 0644);
    struct 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, (struct sockaddr*)&addr, sizeof addr);
    fs::create_symlink("file", "sandbox/symlink");
    // Demonstration verschiedener Statusabfragen
    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 Statusaufrufe
    demo_status("dev/sda", fs::status("/dev/sda"));
    demo_status("sandbox/no", fs::status("/sandbox/no"));
    // Bereinigung
    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

Bestimmt Dateiattribute
Bestimmt Dateiattribute, überprüft das Symlink-Ziel
(Funktion)
Repräsentiert Dateityp und Berechtigungen
(Klasse)
Überprüft, ob der Dateistatus bekannt ist
(Funktion)
Überprüft, ob der angegebene Pfad auf ein Zeichengerät verweist
(Funktion)
Überprüft, ob der angegebene Pfad auf ein Verzeichnis verweist
(Funktion)
Überprüft, ob der angegebene Pfad auf eine benannte Pipe verweist
(Funktion)
Überprüft, ob das Argument auf eine andere Datei verweist
(Funktion)
Überprüft, ob das Argument auf eine reguläre Datei verweist
(Funktion)
Überprüft, ob das Argument auf einen benannten IPC-Socket verweist
(Funktion)
Überprüft, ob das Argument auf einen symbolischen Link verweist
(Funktion)
Überprüft, ob der Pfad auf ein existierendes Dateisystemobjekt verweist
(Funktion)
Gecachter Status der durch diesen Verzeichniseintrag bezeichneten Datei
Gecachter Symlink-Status der durch diesen Verzeichniseintrag bezeichneten Datei
(Öffentliche Mitgliedsfunktion von std::experimental::filesystem::directory_entry )