Namespaces
Variants

std::filesystem::directory_entry:: is_block_file

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
std::filesystem::directory_entry
Member functions
Modifiers
Observers
directory_entry::is_block_file
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
Non-member functions
bool is_block_file ( ) const ;
(1) (desde C++17)
bool is_block_file ( std:: error_code & ec ) const noexcept ;
(2) (desde C++17)

Comprueba si el objeto apuntado es un dispositivo de bloques. Efectivamente devuelve:

1) std:: filesystem :: is_block_file ( status ( ) ) .
2) std:: filesystem :: is_block_file ( status ( ec ) ) .

Contenidos

Parámetros

ec - parámetro de salida para reporte de errores en la sobrecarga que no lanza excepciones

Valor de retorno

true si el objeto del sistema de archivos referenciado es un dispositivo de bloque, false en caso contrario.

Excepciones

Cualquier sobrecarga no marcada como noexcept puede lanzar std::bad_alloc si la asignación de memoria falla.

1) Lanza std::filesystem::filesystem_error en errores de la API del sistema operativo subyacente, construido con p como primer argumento de ruta y el código de error del sistema operativo como argumento de código de error.
2) Establece un parámetro std:: error_code & al código de error de la API del sistema operativo si una llamada a la API del SO falla, y ejecuta ec. clear ( ) si no ocurren errores.

Ejemplo

Ejecutar este código 
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <memory>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>
namespace fs = std::filesystem;
void print_entry_type(const std::filesystem::directory_entry& entry)
{
    std::cout << entry.path() << ": ";
    if (!entry.exists())
        std::cout << "no existe ";
    if (entry.is_block_file())
        std::cout << "es un dispositivo de bloques ";
    if (entry.is_character_file())
        std::cout << "es un dispositivo de caracteres ";
    if (entry.is_directory())
        std::cout << "es un directorio ";
    if (entry.is_fifo())
        std::cout << "es una tubería IPC con nombre ";
    if (entry.is_regular_file())
        std::cout << "es un archivo regular ";
    if (entry.is_socket())
        std::cout << "es un socket IPC con nombre ";
    if (entry.is_symlink())
        std::cout << "(un enlace simbólico)";
    if (entry.is_other())
        std::cout << "(un `otro` archivo)";
    std::cout << '\n';
}
template<typename Type, typename Fun>
class scoped_cleanup
{
    std::unique_ptr<Type, std::function<void(const Type*)>> u;
public:
    scoped_cleanup(Type* ptr, Fun fun) : u{ptr, std::mover(fun)} {}
};
int main()
{
    // Crear archivos de diferentes tipos.
    std::filesystem::current_path(fs::temp_directory_path());
    const std::filesystem::path sandbox{"sandbox"};
    scoped_cleanup remove_all_at_exit{&sandbox, [](const fs::path* p)
    {
        std::cout << "cleanup: remove_all(" << *p << ")\n";
        fs::remove_all(*p);
    }};
    std::filesystem::create_directory(sandbox);
    std::ofstream{sandbox/"archivo"}; // Crea un archivo regular
    std::filesystem::create_directory(sandbox/"dir");
    mkfifo((sandbox/"tubería").string().data(), 0644);
    struct sockaddr_un addr; addr.sun_family = AF_UNIX;
    std::strcpy(addr.sun_path, (sandbox/"calcetín").string().data());
    int fd{socket(PF_UNIX, SOCK_STREAM, 0)};
    scoped_cleanup close_socket_at_exit{&fd, [](const int* f)
    {
        std::cout << "limpieza: cerrar socket #" << *f << '\n';
        close(*f);
    }};
    bind(fd, reinterpret_cast<sockaddr*>(std::addressof(addr)), sizeof addr);
    fs::create_symlink("archivo", sandbox/"enlace simbólico");
    for (std::filesystem::directory_entry entry: fs::directory_iterator(sandbox))
        print_entry_type(entry);
    // Solicitar el estado de los objetos del sistema de archivos directamente:
    for (const char* str : {"/dev/null", "/dev/cpu", "/usr/include/c++",
                            "/usr/include/asm", "/usr/include/time.h"})
        print_entry_type(fs::directory_entry{str});
} // Limpieza mediante objetos scoped_cleanup

Salida posible: 

"sandbox/symlink": es un archivo regular (un enlace simbólico) 
"sandbox/sock": es un socket IPC nombrado (un archivo `other`) 
"sandbox/pipe": es una tubería IPC nombrada (un archivo `other`) 
"sandbox/dir": es un directorio 
"sandbox/file": es un archivo regular 
"/dev/null": es un dispositivo de caracteres (un archivo `other`) 
"/dev/cpu": no existe 
"/usr/include/c++": es un directorio 
"/usr/include/asm": es un directorio (un enlace simbólico) 
"/usr/include/time.h": es un archivo regular 
cleanup: cerrar socket #3
cleanup: remove_all("sandbox")

Véase también

(C++17)
comprueba si la ruta dada se refiere a un dispositivo de bloques
(función)