Namespaces
Variants

std::experimental::filesystem:: is_symlink

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

Vérifie si le statut de fichier ou le chemin donné correspond à un lien symbolique, comme déterminé par le standard POSIX S_IFLNK .

1) Équivalent à s. type ( ) == file_type :: symlink .
2) Équivalent à is_symlink ( status ( p ) ) ou is_symlink ( 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 lien symbolique. 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 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, appeler is_symlink(*iterator) est moins efficace que is_symlink(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 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 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 à une socket IPC nommée
(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
statut de lien symbolique en cache du fichier désigné par cette entrée de répertoire
(fonction membre publique de std::experimental::filesystem::directory_entry )