Namespaces
Variants

std::experimental::filesystem:: is_character_file

From cppreference.net
C++
Experimental
Filesystem library
Classes
Functions
File types
Défini dans l'en-tête <experimental/filesystem>
bool is_character_file ( file_status s ) ;
(1) (filesystem TS)
bool is_character_file ( const path & p ) ;
bool is_character_file ( const path & p, error_code & ec ) ;
(2) (filesystem TS)

Vérifie si le statut de fichier ou le chemin donné correspond à un fichier spécial de caractère, comme déterminé par POSIX S_ISCHR . Des exemples de fichiers spéciaux de caractère sont les périphériques caractères tels que / dev / null , / dev / tty , / dev / audio , ou / dev / nvram sous Linux.

1) Équivalent à s. type ( ) == file_type :: character .
2) Équivalent à is_character_file ( status ( p ) ) ou is_character_file ( status ( p, ec ) ) respectivement.

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 correspond à un périphérique de bloc, false sinon. La surcharge non-lancante 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 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_character_file(*iterator) est moins efficace que is_character_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 << " 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 du fichier
détermine les attributs du 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 bloc
(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 du système de fichiers existant
(fonction)
statut en cache du fichier désigné par cette entrée de répertoire
symlink_status en cache du fichier désigné par cette entrée de répertoire
(fonction membre publique de std::experimental::filesystem::directory_entry )