Namespaces
Variants

std::experimental::filesystem:: is_block_file

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

Vérifie si le statut de fichier ou le chemin donné correspond à un fichier spécial de bloc, comme déterminé par la fonction POSIX S_ISBLK . Les exemples de fichiers spéciaux de bloc sont les périphériques de bloc tels que / dev / sda ou / dev / loop0 sur Linux.

1) Équivalent à s. type ( ) == file_type :: block .
2) Équivalent à is_block_file ( status ( p ) ) ou is_block_file ( 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 périphérique de bloc. 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 filesystem_error en cas d'erreurs 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 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 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 à is_block_file(*iterator) est moins efficace que is_block_file(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 << " 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");
}

Sortie possible : 

"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

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 de caractères
(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 à une socket IPC nommée
(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 )