Defined in header <filesystem> | ||
|---|---|---|
enum class file_type {
none = /* unspecified */,
not_found = /* unspecified */,
regular = /* unspecified */,
directory = /* unspecified */,
symlink = /* unspecified */,
block = /* unspecified */,
character = /* unspecified */,
fifo = /* unspecified */,
socket = /* unspecified */,
unknown = /* unspecified */,
/* implementation-defined */
};
| (since C++17) |
file_type defines constants that indicate a type of a file or directory a path refers to. The value of the enumerators are distinct.
| Constant | Meaning |
|---|---|
none | indicates that the file status has not been evaluated yet, or an error occurred when evaluating it |
not_found | indicates that the file was not found (this is not considered an error) |
regular | a regular file |
directory | a directory |
symlink | a symbolic link |
block | a block special file |
character | a character special file |
fifo | a FIFO (also known as pipe) file |
socket | a socket file |
| implementation-defined | an additional implementation-defined constant for each additional file type supported by the implementation (e.g. MSVC STL defines junction for NTFS junctions) |
unknown | the file exists but its type could not be determined |
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
namespace fs = std::filesystem;
void demo_status(const fs::path& p, fs::file_status s)
{
std::cout << p;
switch(s.type())
{
case fs::file_type::none: std::cout << " has `not-evaluated-yet` type"; break;
case fs::file_type::not_found: std::cout << " does not exist"; break;
case fs::file_type::regular: std::cout << " is a regular file"; break;
case fs::file_type::directory: std::cout << " is a directory"; break;
case fs::file_type::symlink: std::cout << " is a symlink"; break;
case fs::file_type::block: std::cout << " is a block device"; break;
case fs::file_type::character: std::cout << " is a character device"; break;
case fs::file_type::fifo: std::cout << " is a named IPC pipe"; break;
case fs::file_type::socket: std::cout << " is a named IPC socket"; break;
case fs::file_type::unknown: std::cout << " has `unknown` type"; break;
default: std::cout << " has `implementation-defined` type"; break;
}
std::cout << '\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);
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, reinterpret_cast<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");
}Possible output:
"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
|
(C++17) | represents file type and permissions (class) |
|
(C++17) | checks whether the given path refers to block device (function) |
|
(C++17) | checks whether the given path refers to a character device (function) |
|
(C++17) | checks whether the given path refers to a directory (function) |
|
(C++17) | checks whether the given path refers to a named pipe (function) |
|
(C++17) | checks whether the argument refers to an other file (function) |
|
(C++17) | checks whether the argument refers to a named IPC socket (function) |
|
(C++17) | checks whether the argument refers to a symbolic link (function) |
| checks whether the directory entry refers to a regular file (public member function of std::filesystem::directory_entry) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/filesystem/file_type