std::experimental::filesystem::is_socket

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Experimentell

Technische Spezifikation

Dateisystembibliothek (Filesystem TS)

Grundlagen der Bibliothek (Library Fundamentals TS)

Grundlagen der Bibliothek 2 (Library Fundamentals TS v2)

Grundlagen der Bibliothek 3 (Library Fundamentals TS v3)

Erweiterungen für Parallelität (Parallelism TS)

Erweiterungen für Parallelität 2 (Parallelism TS v2)

Erweiterungen für Nebenläufigkeit (Concurrency TS)

Erweiterungen für Nebenläufigkeit 2 (Concurrency TS v2)

Konzepte (Concepts TS)

Bereiche (Ranges TS)

Reflektion (Reflection TS)

Mathematische Spezialfunktionen (Special Functions TR)

Experimentell Nicht-TS

Pattern Matching

Lineare Algebra

std::execution

Verträge

2D-Grafik

 

Dateisystem-Bibliothek

Klassen
filesystem::path filesystem::filesystem_error filesystem::directory_entry filesystem::directory_iterator filesystem::recursive_directory_iterator filesystem::file_status	filesystem::space_info filesystem::file_type filesystem::perms filesystem::copy_options filesystem::directory_options filesystem::file_time_type
Funktionen
filesystem::absolute filesystem::system_complete filesystem::canonical filesystem::copy filesystem::copy_file filesystem::copy_symlink filesystem::create_directory filesystem::create_directories filesystem::create_hard_link filesystem::create_symlink filesystem::create_directory_symlink filesystem::current_path filesystem::exists filesystem::equivalent	filesystem::file_size filesystem::hard_link_count filesystem::last_write_time filesystem::permissions filesystem::read_symlink filesystem::remove filesystem::remove_all filesystem::rename filesystem::resize_file filesystem::space filesystem::status filesystem::symlink_status filesystem::temp_directory_path
Dateitypen
filesystem::is_block_file filesystem::is_character_file filesystem::is_directory filesystem::is_empty filesystem::status_known	filesystem::is_fifo filesystem::is_other filesystem::is_regular_file filesystem::is_socket filesystem::is_symlink

 

Definiert im Header <experimental/filesystem>
bool is_socket( file_status s );	(1)	(Dateisystem-TS)
bool is_socket( const path& p ); bool is_socket( const path& p, error_code& ec );	(2)	(Dateisystem-TS)

Prüft, ob der gegebene Dateistatus oder Pfad einem benannten IPC-Socket entspricht, wie durch die POSIX S_IFSOCK ermittelt wird.

1) Entspricht s.type() == file_type::socket.

2) Entspricht is_socket(status(p)) oder is_socket(status(p, ec)).

Parameter

s	-	Dateistatus zum Prüfen
p	-	Zu untersuchender Pfad
ec	-	Ausgabeparameter für die Fehlerberichterstattung in der nicht auslösenden Überladung

Rückgabewert

true, wenn die durch p angezeigte Datei oder der durch s angezeigte Typ auf einen benannten Socket verweist. Die nicht-auslösende Überladung gibt false zurück, wenn ein Fehler auftritt.

Ausnahmen

1)

noexcept-Spezifikation:  

noexcept

  

2) Die Überladung, die keinen Parameter vom Typ error_code& annimmt, löst filesystem_error bei zugrundeliegenden Betriebssystem-API-Fehlern aus, konstruiert mit p als erstem Argument und dem Betriebssystem-Fehlercode als Fehlercode-Argument. std::bad_alloc kann ausgelöst werden, wenn die Speicherzuweisung fehlschlägt. Die Überladung, die einen Parameter vom Typ error_code& annimmt, setzt diesen auf den Betriebssystem-API-Fehlercode, wenn ein Betriebssystem-API-Aufruf fehlschlägt, und führt ec.clear() aus, wenn keine Fehler auftreten. Diese Überladung hat

noexcept-Spezifikation:  

noexcept

  

Hinweise

Benannte Sockets sind UNIX-Domain-Sockets, die mit den POSIX-APIs socket und bind erstellt werden und für fortgeschrittene Interprozesskommunikation verwendet werden können. Insbesondere können sie verwendet werden, um offene Dateideskriptoren von einem laufenden Prozess zu einem anderen zu transportieren.

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

Führen Sie diesen Code aus

#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 << " is a regular file\n";
    if (fs::is_directory(s))
        std::cout << " is a directory\n";
    if (fs::is_block_file(s))
        std::cout << " is a block device\n";
    if (fs::is_character_file(s))
        std::cout << " is a character device\n";
    if (fs::is_fifo(s))
        std::cout << " is a named IPC pipe\n";
    if (fs::is_socket(s))
        std::cout << " is a named IPC socket\n";
    if (fs::is_symlink(s))
        std::cout << " is a symlink\n";
    if (!fs::exists(s))
        std::cout << " does not exist\n";
}
 
int main()
{
    // create files of different kinds
    fs::create_directory("sandbox");
    std::ofstream("sandbox/file"); // create regular file
    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");
 
    // demo different status accessors
    for (auto it = fs::directory_iterator("sandbox"); it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // use cached status from directory entry
    demo_status("dev/null", fs::status("/dev/null")); // direct calls to status
    demo_status("dev/sda", fs::status("/dev/sda"));
    demo_status("sandbox/no", fs::status("/sandbox/no"));
 
    // cleanup
    close(fd);
    fs::remove_all("sandbox");
}

Mögliche Ausgabe

"sandbox/file" is a regular file
"sandbox/dir" is a directory
"sandbox/pipe" is a named IPC pipe
"sandbox/sock" is a named IPC socket
"sandbox/symlink" is a symlink
"dev/null" is a character device
"dev/sda" is a block device
"sandbox/no" does not exist

Siehe auch

statussymlink_status	ermittelt Dateiattribute ermittelt Dateiattribute, wobei das Ziel des symbolischen Links geprüft wird (Funktion)
file_status	repräsentiert Dateityp und Berechtigungen (Klasse)
status_known	prüft, ob der Dateistatus bekannt ist (Funktion)
is_block_file	prüft, ob der gegebene Pfad auf ein Blockgerät verweist (Funktion)
is_character_file	prüft, ob der gegebene Pfad auf ein Zeichengerät verweist (Funktion)
is_directory	prüft, ob der gegebene Pfad auf ein Verzeichnis verweist (Funktion)
is_fifo	prüft, ob der gegebene Pfad auf eine benannte Pipe verweist (Funktion)
is_other	prüft, ob das Argument auf eine andere Datei verweist (Funktion)
is_regular_file	prüft, ob das Argument auf eine reguläre Datei verweist (Funktion)
is_symlink	prüft, ob das Argument auf einen symbolischen Link verweist (Funktion)
exists	prüft, ob ein Pfad auf ein existierendes Dateisystemobjekt verweist (Funktion)
statussymlink_status	gecacheter Status der von diesem Verzeichniseintrag bezeichneten Datei gecacheter symlink_status der von diesem Verzeichniseintrag bezeichneten Datei (öffentliche Memberfunktion von std::experimental::filesystem::directory_entry)