Namespaces
Variants

std::experimental::filesystem:: is_socket

From cppreference.net
C++
Experimental
Filesystem library
Classes
Functions
File types
Défini dans l'en-tête <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)

Vérifie si le statut de fichier ou le chemin donné correspond à un socket IPC nommé, comme déterminé par la norme POSIX S_IFSOCK .

1) Équivalent à s. type ( ) == file_type :: socket .
2) Équivalent à is_socket ( status ( p ) ) ou is_socket ( status ( p, ec ) ) .

Table des matières

Paramètres

s - statut du fichier à vérifier
p - chemin à examiner
ec - paramètre de sortie pour le rapport d'erreur dans la surcharge non-lancée

Valeur de retour

true si le fichier indiqué par p ou si le type indiqué par s fait référence à un socket nommé. La surcharge non levante retourne false si une erreur survient.

Exceptions

1)
noexcept spécification :
noexcept
2) La surcharge qui ne prend pas de paramètre error_code & lance une exception filesystem_error en cas d'erreur de l'API système sous-jacente, construite avec p comme premier argument et le code d'erreur du système comme argument de code d'erreur. std:: bad_alloc peut être levée si l'allocation de mémoire échoue. La surcharge prenant un paramètre error_code & le définit sur le code d'erreur de l'API système si un appel d'API système échoue, et exécute ec. clear ( ) si aucune erreur ne survient. Cette surcharge possède la spécification
noexcept :
noexcept

Notes

Les sockets nommés sont des sockets de domaine UNIX construits avec les API POSIX socket et bind , qui peuvent être utilisés pour une communication interprocessus avancée. En particulier, ils peuvent être utilisés pour transférer des descripteurs de fichiers ouverts d'un processus en cours d'exécution à un autre.

Les informations fournies par cette fonction sont généralement également disponibles comme sous-produit de l'itération de répertoire. Pendant l'itération de répertoire, l'appel de is_socket(*iterator) est moins efficace que is_socket(iterator->status()) .

Exemple

Exécuter ce code 
#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 << " est un fichier régulier\n";
    if (fs::is_directory(s))
        std::cout << " est un répertoire\n";
    if (fs::is_block_file(s))
        std::cout << " est un périphérique bloc\n";
    if (fs::is_character_file(s))
        std::cout << " est un périphérique caractère\n";
    if (fs::is_fifo(s))
        std::cout << " est un tube IPC nommé\n";
    if (fs::is_socket(s))
        std::cout << " est un socket IPC nommé\n";
    if (fs::is_symlink(s))
        std::cout << " est un lien symbolique\n";
    if (!fs::exists(s))
        std::cout << " n'existe pas\n";
}
int main()
{
    // créer des fichiers de différents types
    fs::create_directory("sandbox");
    std::ofstream("sandbox/file"); // créer un fichier régulier
    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");
    // démontrer différents accesseurs de statut
    for (auto it = fs::directory_iterator("sandbox"); it != fs::directory_iterator(); ++it)
        demo_status(*it, it->symlink_status()); // utiliser le statut mis en cache de l'entrée de répertoire
    demo_status("dev/null", fs::status("/dev/null")); // appels directs à status
    demo_status("dev/sda", fs::status("/dev/sda"));
    demo_status("sandbox/no", fs::status("/sandbox/no"));
    // nettoyage
    close(fd);
    fs::remove_all("sandbox");
}

Sortie possible : 

"sandbox/file" est un fichier régulier
"sandbox/dir" est un répertoire
"sandbox/pipe" est un tube IPC nommé
"sandbox/sock" est un socket IPC nommé
"sandbox/symlink" est un lien symbolique
"dev/null" est un périphérique caractère
"dev/sda" est un périphérique bloc
"sandbox/no" n'existe pas

Voir aussi

détermine les attributs de fichier
détermine les attributs de fichier en vérifiant la cible du lien symbolique
(fonction)
représente le type de fichier et les permissions
(classe)
vérifie si le statut du fichier est connu
(fonction)
vérifie si le chemin donné fait référence à un périphérique bloc
(fonction)
vérifie si le chemin donné fait référence à un périphérique caractère
(fonction)
vérifie si le chemin donné fait référence à un répertoire
(fonction)
vérifie si le chemin donné fait référence à un tube nommé
(fonction)
vérifie si l'argument fait référence à un fichier autre
(fonction)
vérifie si l'argument fait référence à un fichier régulier
(fonction)
vérifie si l'argument fait référence à un lien symbolique
(fonction)
vérifie si le chemin fait référence à un objet de système de fichiers existant
(fonction)
statut mis en cache du fichier désigné par cette entrée de répertoire
symlink_status mis en cache du fichier désigné par cette entrée de répertoire
(fonction membre publique de std::experimental::filesystem::directory_entry )