Namespaces
Variants

std::experimental::filesystem:: is_symlink

From cppreference.net
C++
Experimental
Filesystem library
Classes
Functions
File types
Definiert im Header <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)

Prüft, ob der angegebene Dateistatus oder Pfad einem symbolischen Link entspricht, wie durch das POSIX- S_IFLNK bestimmt.

1) Entspricht s. type ( ) == file_type :: symlink .
2) Entspricht is_symlink ( status ( p ) ) oder is_symlink ( status ( p, ec ) ) .

Inhaltsverzeichnis

Parameter

s - zu prüfender Dateistatus
p - zu untersuchender Pfad
ec - Ausgabeparameter für Fehlerberichterstattung in der nicht-werfenden Überladung

Rückgabewert

true wenn die durch p angegebene Datei oder der durch s angegebene Typ auf einen symbolischen Link verweist. Die nicht-werfende Überladung gibt false zurück, wenn ein Fehler auftritt.

Ausnahmen

1)
noexcept Spezifikation:
noexcept
2) Die Überladung, die keinen error_code & Parameter akzeptiert, wirft bei zugrundeliegenden OS-API-Fehlern filesystem_error , konstruiert mit p als erstem Argument und dem OS-Fehlercode als Fehlercode-Argument. std:: bad_alloc kann geworfen werden, wenn die Speicherallokation fehlschlägt. Die Überladung, die einen error_code & Parameter akzeptiert, setzt diesen auf den OS-API-Fehlercode, wenn ein OS-API-Aufruf fehlschlägt, und führt ec. clear ( ) aus, wenn keine Fehler auftreten. Diese Überladung hat
noexcept Spezifikation:
noexcept

Hinweise

Die von dieser Funktion bereitgestellten Informationen werden normalerweise auch als Nebenprodukt der Verzeichnisiteration bereitgestellt. Während der Verzeichnisiteration ist der Aufruf von is_symlink(*iterator) weniger effizient als is_symlink(iterator->status()) .

Beispiel

Diesen Code ausführen 
#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");
}

Mögliche Ausgabe: 

"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

Siehe auch

bestimmt Dateiattribute
bestimmt Dateiattribute, überprüft das Symlink-Ziel
(Funktion)
repräsentiert Dateityp und Berechtigungen
(Klasse)
prüft, ob der Dateistatus bekannt ist
(Funktion)
prüft, ob der gegebene Pfad auf ein Blockgerät verweist
(Funktion)
prüft, ob der gegebene Pfad auf ein Zeichengerät verweist
(Funktion)
prüft, ob der gegebene Pfad auf ein Verzeichnis verweist
(Funktion)
prüft, ob der gegebene Pfad auf eine benannte Pipe verweist
(Funktion)
prüft, ob das Argument auf eine andere Datei verweist
(Funktion)
prüft, ob das Argument auf eine reguläre Datei verweist
(Funktion)
prüft, ob das Argument auf einen benannten IPC-Socket verweist
(Funktion)
prüft, ob der Pfad auf ein existierendes Dateisystemobjekt verweist
(Funktion)
zwischengespeicherter Status der durch diesen Verzeichniseintrag bezeichneten Datei
zwischengespeicherter Symlink-Status der durch diesen Verzeichniseintrag bezeichneten Datei
(öffentliche Mitgliedsfunktion von std::experimental::filesystem::directory_entry )