Namespaces
Variants

std::experimental::filesystem::directory_entry:: status, std::experimental::filesystem::directory_entry:: symlink_status

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
directory_entry
file_status status ( ) const ;
file_status status ( error_code & ec ) const ;
(1) (filesystem TS)
file_status symlink_status ( ) const ;
file_status symlink_status ( error_code & ec ) const ;
(2) (filesystem TS)
1) Retourne l'état potentiellement mis en cache de l'entrée, comme s'il était déterminé par un appel status (les liens symboliques sont suivis vers leurs cibles).
2) Retourne l'état potentiellement mis en cache de l'entrée, comme s'il était déterminé par un appel symlink_status (les liens symboliques ne sont pas suivis).

Table des matières

Paramètres

ec - paramètre de sortie pour le rapport d'erreur dans la surcharge non-lancante

Valeur de retour

Le statut du fichier référencé par l'entrée.

Exceptions

The overload that does not take an error_code & parameter throws filesystem_error on underlying OS API errors, constructed with p as the first argument and the OS error code as the error code argument. std:: bad_alloc **Note:** Le code HTML reste inchangé car : - Les balises HTML et attributs ne doivent pas être traduits - Le texte contenu dans les balises est du code C++ (`std::bad_alloc`) qui ne doit pas être traduit - `std::bad_alloc` est un terme spécifique au C++ qui doit conserver sa forme originale may be thrown if memory allocation fails. The overload taking an error_code & parameter sets it to the OS API error code if an OS API call fails, and executes ec. clear ( ) if no errors occur. This overload has
noexcept spécification :
noexcept

Notes

Les informations sur l'état du fichier sont généralement fournies comme sous-produit de l'itération de répertoire, auquel cas elles sont mises en cache et peuvent être obtenues par ces fonctions membres sans le coût d'un appel système supplémentaire. Pendant l'itération de répertoire, appeler status est inutile et les accesseurs tels que is_directory doivent être appelés avec la valeur d'état mise en cache, et non avec un chemin.

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

représente le type de fichier et les permissions
(classe)
détermine les attributs de fichier
détermine les attributs de fichier, en vérifiant la cible du lien symbolique
(fonction)
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 périphérique de 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 à une socket IPC nommée
(fonction)
vérifie si l'argument fait référence à un lien symbolique
(fonction)