Namespaces
Variants

std::experimental::filesystem:: is_socket

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

Prüft, ob der angegebene Dateistatus oder Pfad einem benannten IPC-Socket entspricht, wie durch das POSIX- S_IFSOCK bestimmt.

1) Entspricht s. type ( ) == file_type :: socket .
2) Entspricht is_socket ( status ( p ) ) oder is_socket ( 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 einen benannten Socket verweist. Die nicht-werfende Überladung gibt false zurück, falls 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

Named Sockets sind UNIX-Domain-Sockets, die mit den socket und bind POSIX-APIs erstellt werden und für erweiterte Interprozesskommunikation verwendet werden können. Insbesondere können sie zum Transport geöffneter Dateideskriptoren von einem laufenden Prozess zu einem anderen verwendet werden.

Die von dieser Funktion bereitgestellten Informationen werden normalerweise auch als Nebenprodukt der Verzeichnisiteration bereitgestellt. Während der Verzeichnisiteration ist der Aufruf von is_socket(*iterator) weniger effizient als is_socket(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)
prüft, ob der Dateistatus bekannt ist
(Funktion)
prüft, ob der angegebene Pfad auf ein Blockgerät verweist
(Funktion)
prüft, ob der angegebene Pfad auf ein Zeichengerät verweist
(Funktion)
prüft, ob der angegebene Pfad auf ein Verzeichnis verweist
(Funktion)
prüft, ob der angegebene Pfad auf eine benannte Pipe verweist
(Funktion)
prüft, ob das Argument auf eine andere Datei verweist
(Funktion)
prüft, ob das Argument auf eine reguläre Datei verweist
(Funktion)
prüft, ob das Argument auf einen symbolischen Link verweist
(Funktion)
prüft, ob der Pfad auf ein existierendes Dateisystemobjekt verweist
(Funktion)
zwischengespeicherter Status der durch diesen Verzeichniseintrag bezeichneten Datei
zwischengespeicherter Symlink-Status der durch diesen Verzeichniseintrag bezeichneten Datei
(öffentliche Mitgliedsfunktion von std::experimental::filesystem::directory_entry )