Filesystem library

官方文档：https://en.cppreference.com/w/cpp/filesystem

Filesystem 由 boost.filesystem 发展而来，自 C++17 开始引入到 ISO C++ 中，用于操作文件系统及其组件（路径、常规文件及文件夹等）。如果希望在较低版本的 C++ 编译器中使用 filesystem，需要换用 boost。

1、类

• 定义于头文件 <filiesystem>
• 定义于命名空间 std::filesystem

这里面的各类不再一一列举，它们的功能直接通过下面表格里的链接跳转到官方页面即可。

path	路径
filesystem_error	文件系统错误异常
directory_entry	文件夹
directory_iterator	文件夹内容的迭代器
recursive_directory_iterator	递归式迭代指定路径下的所有文件及文件夹
file_status	文件类型及权限
space_info	文件系统中可用的剩余空间信息
file_type	文件类型
perms	文件系统权限标识符
perm_options	指明权限操作的语义
copy_options	指明复制操作的语义
directory_options	对文件夹内容进行迭代时的选项
file_time_type	文件时间信息

2、非成员函数

• 定义于头文件 <filiesystem>
• 定义于命名空间 std::filesystem

absolute	绝对路径
canonical、weakly_canonical	将相对路径转为绝对路径
relative、proximate	相对路径
copy	复制文件或者文件夹
copy_file	复制文件内容
copy_symlink	复制符号链接
create_directory、create_directories	创建新文件夹
create_hard_link	创建硬链接
create_symlink、create_directory_symlink	创建符号链接
current_path	返回或修改当前工作路径
exists	判断路径是否存在
equivalent	判断两个路径是否相同
file_size	返回文件大小
hard_link_count	返回指定文件的硬链接数量
last_write_time	获取或设置最近一次修改数据的时间
permissions	修改访问权限
read_symlink	获取符号链接的目标
remove、remove_all	删除文件或空文件夹，后者可递归式删除非空文件夹
rename	重命名文件或文件夹
resize_file	改变常规文件的大小
space	确定文件系统中的可用剩余空间
status、symlink_status	确定文件属性；检查符号链接目标
temp_directory_path	返回一个存放临时文件的文件夹

2.1、std::filesystem::absolute

定义于 <filesystem>

返回包含 p 在内的绝对路径

path absolute( const std::filesystem::path& p );
path absolute( const std::filesystem::path& p, std::error_code& ec );

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

第一个函数在底层系统 API 错误上抛出 std::filesystem::filesystem_error，构建时将 p 作为第一个路径参数，将系统错误代码作为错误代码参数。

如果系统 API 调用失败，第二个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

注意：
对 p 不存在的情况，并非异常；

对基于 POSIX 的系统来说，std::filesystem::absolute(p) 等价于 std::filesystem::current_path() / p；

对 Windows 来说，std::filesystem::absolute 可能是基于 GetFullPathNameW 开发的。

案例：

#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{std::filesystem::path p = "foo.c";std::cout << "Current path is " << std::filesystem::current_path() << '\n';std::cout << "Absolute path for " << p << " is " << fs::absolute(p) << '\n';
}

输出：

Current path is "/tmp/1666297965.0051296"
Absolute path for "foo.c" is "/tmp/1666297965.0051296/foo.c"

2.2、std::filesystem::canonical, std::filesystem::weakly_canonical

定义于 <filesystem>

将 p 转换为规范的绝对路径，这两个函数的差异可以详见后面的案例

path canonical( const std::filesystem::path& p );
path canonical( const std::filesystem::path& p,std::error_code& ec );
path weakly_canonical( const std::filesystem::path& p );
path weakly_canonical( const std::filesystem::path& p,std::error_code& ec );

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

不带 ec 的几个函数在底层系统 API 错误上抛出 std::filesystem::filesystem_error，构建时将 p 作为第一个路径参数，将系统错误代码作为错误代码参数。

如果系统 API 调用失败，另外几个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例：

#include <filesystem>
#include <iostream>int main()
{/* set up sandbox directories:a└── b├── c1│   └── d <== current path└── c2└── e*/auto old = std::filesystem::current_path();auto tmp = std::filesystem::temp_directory_path();std::filesystem::current_path(tmp);auto d1 = tmp / "a/b/c1/d";auto d2 = tmp / "a/b/c2/e";std::filesystem::create_directories(d1);std::filesystem::create_directories(d2);std::filesystem::current_path(d1);auto p1 = std::filesystem::path("../../c2/./e");auto p2 = std::filesystem::path("../no-such-file");std::cout << "Current path is "<< std::filesystem::current_path() << '\n'<< "Canonical path for " << p1 << " is "<< std::filesystem::canonical(p1) << '\n'<< "Weakly canonical path for " << p2 << " is "<< std::filesystem::weakly_canonical(p2) << '\n';try{[[maybe_unused]] auto x_x = std::filesystem::canonical(p2);// NOT REACHED}catch (const std::exception& ex){std::cout << "Canonical path for " << p2 << " threw exception:\n"<< ex.what() << '\n';}// cleanupstd::filesystem::current_path(old);const auto count = std::filesystem::remove_all(tmp / "a");std::cout << "Deleted " << count << " files or directories.\n";
}

输出：

Current path is "/tmp/a/b/c1/d"
Canonical path for "../../c2/./e" is "/tmp/a/b/c2/e"
Weakly canonical path for "../no-such-file" is "/tmp/a/b/c1/no-such-file"
Canonical path for "../no-such-file" threw exception:
filesystem error: in canonical: No such file or directory [../no-such-file] [/tmp/a/b/c1/d]
Deleted 6 files or directories.

2.3、std::filesystem::relative, std::filesystem::proximate

定义于 <filesystem>

返回相对路径，具体使用方法见后面的案例

path relative( const std::filesystem::path& p,std::error_code& ec );
path relative( const std::filesystem::path& p,const std::filesystem::path& base = std::filesystem::current_path() );
path relative( const std::filesystem::path& p,const std::filesystem::path& base,std::error_code& ec );
path proximate( const std::filesystem::path& p,std::error_code& ec );
path proximate( const std::filesystem::path& p,const std::filesystem::path& base = std::filesystem::current_path() );
path proximate( const std::filesystem::path& p,const std::filesystem::path& base,std::error_code& ec );

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

不带 ec 参数的函数在底层系统 API 错误上抛出 std::filesystem::filesystem_error，构建时将 p 作为第一个路径参数，将系统错误代码作为错误代码参数。

如果系统 API 调用失败，另外几个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例：

#include <filesystem>
#include <iostream>void show(std::filesystem::path x, std::filesystem::path y)
{std::cout << "x:\t\t " << x << "\ny:\t\t " << y << '\n'<< "relative(x, y):  "<< std::filesystem::relative(x, y) << '\n'<< "proximate(x, y): "<< std::filesystem::proximate(x, y) << "\n\n";
}int main()
{show("/a/b/c", "/a/b");show("/a/c", "/a/b");show("c", "/a/b");show("/a/b", "c");
}

输出：

x:               "/a/b/c"
y:               "/a/b"
relative(x, y):  "c"
proximate(x, y): "c"x:               "/a/c"
y:               "/a/b"
relative(x, y):  "../c"
proximate(x, y): "../c"x:               "c"
y:               "/a/b"
relative(x, y):  ""
proximate(x, y): "c"x:               "/a/b"
y:               "c"
relative(x, y):  ""
proximate(x, y): "/a/b"

2.4、std::filesystem::copy

定义于 <filesystem>

可以以指定复制方案的方式，对文件或者文件夹进行复制

void copy( const std::filesystem::path& from,const std::filesystem::path& to );
void copy( const std::filesystem::path& from,const std::filesystem::path& to,std::error_code& ec );
void copy( const std::filesystem::path& from,const std::filesystem::path& to,std::filesystem::copy_options options );
void copy( const std::filesystem::path& from,const std::filesystem::path& to,std::filesystem::copy_options options,std::error_code& ec );

案例：

#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;int main()
{fs::create_directories("sandbox/dir/subdir");std::ofstream("sandbox/file1.txt").put('a');fs::copy("sandbox/file1.txt", "sandbox/file2.txt"); // copy filefs::copy("sandbox/dir", "sandbox/dir2"); // copy directory (non-recursive)const auto copyOptions = fs::copy_options::update_existing| fs::copy_options::recursive| fs::copy_options::directories_only;fs::copy("sandbox", "sandbox_copy", copyOptions); static_cast<void>(std::system("tree"));fs::remove_all("sandbox");fs::remove_all("sandbox_copy");
}

输出：

.
├── sandbox
│   ├── dir
│   │   └── subdir
│   ├── dir2
│   ├── file1.txt
│   └── file2.txt
└── sandbox_copy├── dir│   └── subdir└── dir28 directories, 2 files

异常的情况与其他函数基本相同，后面不再赘述。

函数在执行时的具体行为

• 首先，在执行任何其他操作之前，只需对下面的两个函数进行一次调用，即可获得 from 的类型和权限：
  • std：：filesystem::symlink_status（如果在 options 中指定了 copy_options::skip_symlinks, copy_options::copy_symlinks, 或 copy_options::create_symlinks）
  • std::filesystem::status （其他情况）
• 如果有必要，只需对下面的两个函数进行一次调用，即可获得 to 的状态：
  • std::filesystem::symlink_status（如果在 options 中指定了 copy_options::skip_symlinks, 或 copy_options::create_symlinks））
  • std::filesystem::status （包含在 options 中指定 copy_options::copy_symlinks 在内的其他情况）
• 如果 from 或 to 中有 implementation-defined 文件类型，则函数的执行效果也是 implementation-defined；
• 如果 from 不存在，函数将报错；
• 如果 from 与 to 是相同的，函数将报错（具体来说，两者是通过函数 std::filesystem::equivalent 判定是否相同的）；
• 如果 from 或 to 不是常规文件、文件夹或者符号链接，则函数报错（通过函数 std::filesystem::is_other 判定的）；
• 如果 from 是文件夹，to 是常规文件，则函数报错；
• 如果 from 是符号链接，则有（以下三条，优先级逐渐降低）：
  • 如果 options 中有 copy_options::skip_symlink，则函数啥也不干
  • 否则，如果 to 不存在，且 options 中有 copy_options::copy_symlinks，则函数的行为与 copy_symlink(from, to) 一致；
  • 对不含上面情况的其他情形，函数报错；
• 如果 from 是常规文件，则有（以下五条，优先级逐渐降低）：
  • 如果设置 options 为 copy_options::directories_only，则函数啥也不干；
  • 否则，如果 options 中有 copy_options::create_symlinks，函数创建一个符号链接（from 必须为绝对路径）
  • 否则，如果 options 中有 copy_options::create_hard_links，函数创建一个硬链接
  • 否则，如果 to 是文件夹，那函数的行为与 copy_file(from, to/from.filename(), options) 相同（即在 to 中创建一个文件）
  • 否则，与函数 copy_file(from, to, options) 的表现相同。
• 如果 from 是文件夹，并且在 options 中设置了 copy_options::create_symlinks，函数将会报错，相应的错误代码为 std::make_error_code(std::errc::is_a_directory)；
• 如果 from 是文件夹，而 options 中设置了 copy_options::recursive 或 copy_options::none，则：
  • 如果 to 不存在，函数将先执行 create_directory(to, from)，
  • 然后，在 from 中含有的文件中进行迭代（使用了 for (const std::filesystem::directory_entry& x : std::filesystem::directory_iterator(from))），并在每个子文件夹中递归地调用 copy(x.path(), to/x.path().filename(), options | in-recursive-copy)
• 对 from 与 to 的其他情况，函数什么也不做。

2.5、std::filesystem::copy_file

定义于 <filesystem>

可以以指定复制方案的方式，对文件进行复制

bool copy_file( const std::filesystem::path& from,const std::filesystem::path& to );
bool copy_file( const std::filesystem::path& from,const std::filesystem::path& to,std::error_code& ec );
bool copy_file( const std::filesystem::path& from,const std::filesystem::path& to,std::filesystem::copy_options options );
bool copy_file( const std::filesystem::path& from,const std::filesystem::path& to,std::filesystem::copy_options options,std::error_code& ec );

案例：

#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;int main()
{fs::create_directory("sandbox");std::ofstream("sandbox/file1.txt").put('a');fs::copy_file("sandbox/file1.txt", "sandbox/file2.txt");// now there are two files in sandbox:std::cout << "file1.txt holds: "<< std::ifstream("sandbox/file1.txt").rdbuf() << '\n';std::cout << "file2.txt holds: "<< std::ifstream("sandbox/file2.txt").rdbuf() << '\n';// fail to copy directoryfs::create_directory("sandbox/abc");try{fs::copy_file("sandbox/abc", "sandbox/def");}catch (fs::filesystem_error& e){std::cout << "Could not copy sandbox/abc: " << e.what() << '\n';}fs::remove_all("sandbox");
}

输出：

file1.txt holds: a
file2.txt holds: a
Could not copy sandbox/abc: copy_file: Is a directory: "sandbox/abc", "sandbox/def"

函数执行时的行为

• 前两个函数相当于在后两个函数中为 options 设置 copy_options::none；
• 后两个函数中，基于 options 中的设置内容，从 from 中复制一份文件到 to 中。如果 options 中的任何copy_options 选项组中存在多个 option，则函数的行为未定义。
  • 如果 !filesystem::is_regular_file(from) 为 true，则函数报错；
  • 否则，如果 to 不存在，
    • 复制 from 的内容及属性；
  • 否则，如果 to 已经存在了，
    • 如果有下面的情况，函数就报错：
      • to 与 from 相同（由 filesystem::equivalent(from, to) 判定）
      • to 不是常规文件（由 ! filesystem::is_regular_file(to) 判定）
      • options 中没有设置控制选项
    • 否则，如果在 options 中设置了 copy_options::skip_existing，则函数什么也不做；
    • 否则，如果在 options 中设置了 copy_options::overwrite_existing，执行复制操作，替换掉已有文件；
    • 否则，如果在 options 中设置了 copy_options::update_existing，则仅在 from 比 to 较新的时候才会进行复制（用 filesystem::last_write_time() 的执行结果判定 from 是否比 to 新）

2.6、std::filesystem::copy_symlink

定义于 <filesystem>

可以以指定复制方案的方式，对符号链接进行复制

第一个函数依据 from 是文件还是文件夹，将以 f(read_symlink(from), to) 的形式调用函数 create_symlink 或 create_directory_symlink；

第二个函数依据 from 是文件还是文件夹，将以 f(read_symlink(from), to, ec) 的形式调用函数 create_symlink 或 create_directory_symlink；

void copy_symlink( const std::filesystem::path& from,const std::filesystem::path& to);
void copy_symlink( const std::filesystem::path& from,const std::filesystem::path& to,std::error_code& ec ) noexcept;

2.7、std::filesystem::create_directory, std::filesystem::create_directories

bool create_directory( const std::filesystem::path& p );
bool create_directory( const std::filesystem::path& p, std::error_code& ec ) noexcept;
bool create_directory( const std::filesystem::path& p,const std::filesystem::path& existing_p );
bool create_directory( const std::filesystem::path& p,const std::filesystem::path& existing_p,std::error_code& ec ) noexcept;
bool create_directories( const std::filesystem::path& p );
bool create_directories( const std::filesystem::path& p, std::error_code& ec );

第三和第四个函数不同于另外四个，它俩创建的新文件夹的属性是从 existing_p 中复制来的（仅在 POSIX 系统中是这样的，在 Windows 中并未复制属性值）：

stat(existing_p.c_str(), &attributes_stat)
mkdir(p.c_str(), attributes_stat.st_mode)

案例：

#include <cassert>
#include <cstdlib>
#include <filesystem>int main()
{std::filesystem::current_path(std::filesystem::temp_directory_path());// Basic usagestd::filesystem::create_directories("sandbox/1/2/a");std::filesystem::create_directory("sandbox/1/2/b");// Directory already exists (false returned, no error)assert(!std::filesystem::create_directory("sandbox/1/2/b"));// Permissions copying usagestd::filesystem::permissions("sandbox/1/2/b",std::filesystem::perms::others_all,std::filesystem::perm_options::remove);std::filesystem::create_directory("sandbox/1/2/c", "sandbox/1/2/b");std::system("ls -l sandbox/1/2");std::system("tree sandbox");std::filesystem::remove_all("sandbox");
}

输出：

drwxr-xr-x 2 user group 4096 Apr 15 09:33 a
drwxr-x--- 2 user group 4096 Apr 15 09:33 b
drwxr-x--- 2 user group 4096 Apr 15 09:33 c
sandbox
└── 1└── 2├── a├── b└── c

2.8、std::filesystem::create_hard_link

void create_hard_link( const std::filesystem::path& target,const std::filesystem::path& link );
void create_hard_link( const std::filesystem::path& target,const std::filesystem::path& link,std::error_code& ec ) noexcept;

该函数将为 target 创建一个硬链接，其中 target 必须设定；
一旦被创建，link 与 target 就成为指向同一个文件的两个逻辑名（它们是等价的），如果 target 被删除，原文件将继续存在，link 也继续指向它。

注意：
一些操作系统不支持硬链接，或者仅在常规文件中支持；

有些操作系统可能支持硬链接，但其中的文件系统可能不支持，例如闪存中的 FAT 文件系统；

一些文件系统对每个文件所能拥有的硬链接的数量进行了限制；

仅管理员具有硬链接到文件夹的权限；

硬链接通常不能跨越文件系统边界。

特殊的路径名 . 是向其父文件夹的一个硬链接，而 .. 是向其父文件夹的父文件夹的一个硬链接。

案例：

#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;int main()
{fs::create_directories("sandbox/subdir");std::ofstream("sandbox/a").put('a'); // create regular filefs::create_hard_link("sandbox/a", "sandbox/b");fs::remove("sandbox/a");// read from the original file via surviving hard linkchar c = std::ifstream("sandbox/b").get();std::cout << c << '\n';fs::remove_all("sandbox");
}

输出：

a

2.9、std::filesystem::create_symlink, std::filesystem::create_directory_symlink

void create_symlink( const std::filesystem::path& target,const std::filesystem::path& link );
void create_symlink( const std::filesystem::path& target,const std::filesystem::path& link,std::error_code& ec ) noexcept;
void create_directory_symlink( const std::filesystem::path& target,const std::filesystem::path& link );
void create_directory_symlink( const std::filesystem::path& target,const std::filesystem::path& link,std::error_code& ec ) noexcept;

创建符号链接

注意：
一些操作系统并不支持符号链接，或者仅在常规文件上支持；

有些操作系统可能支持符号链接，但其中的文件系统可能不支持，例如闪存中的 FAT 文件系统；

与硬链接一样，符号链接允许文件同时拥有多个逻辑名，但硬链接要求原文件必须存在，而符号链接可以独立于原文件存在，且能跨越文件系统边界。

案例：

#include <cassert>
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{fs::create_directories("sandbox/subdir");fs::create_symlink("target", "sandbox/sym1");fs::create_directory_symlink("subdir", "sandbox/sym2");for (auto it = fs::directory_iterator("sandbox"); it != fs::directory_iterator(); ++it)if (is_symlink(it->symlink_status()))std::cout << *it << "->" << read_symlink(*it) << '\n';assert(std::filesystem::equivalent("sandbox/sym2", "sandbox/subdir"));fs::remove_all("sandbox");
}

输出：

"sandbox/sym1"->"target"
"sandbox/sym2"->"subdir"

2.10、std::filesystem::current_path

path current_path();
path current_path( std::error_code& ec );
void current_path( const std::filesystem::path& p );
void current_path( const std::filesystem::path& p,std::error_code& ec ) noexcept;

返回或者修改当前的工作路径

案例：

#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{std::cout << "Current path is " << fs::current_path() << '\n'; // (1)fs::current_path(fs::temp_directory_path()); // (3)std::cout << "Current path is " << fs::current_path() << '\n';
}

输出：

Current path is "D:/local/ConsoleApplication1"
Current path is "E:/Temp"

2.11、std::filesystem::exists

bool exists( std::filesystem::file_status s ) noexcept;
bool exists( const std::filesystem::path& p );
bool exists( const std::filesystem::path& p, std::error_code& ec ) noexcept;

检查当前的文件或文件夹是否存在；

第一个函数等价于 status_known(s) && s.type() != file_type::not_found

第二第三个函数中，令 s 为用 status(p) 或 status(p, ec) 决定的 std::filesystem::file_status，则这两个函数返回的值为 exists(s)，第三个函数在 status_known(s) 为真时，将调用 ec.clear()

案例：

#include <cstdint>
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;void demo_exists(const fs::path& p, fs::file_status s = fs::file_status{})
{std::cout << p;if (fs::status_known(s) ? fs::exists(s) : fs::exists(p))std::cout << " exists\n";elsestd::cout << " does not exist\n";
}int main()
{const fs::path sandbox{"sandbox"};fs::create_directory(sandbox);std::ofstream{sandbox/"file"}; // create regular filefs::create_symlink("non-existing", sandbox/"symlink");demo_exists(sandbox);for (const auto& entry : fs::directory_iterator(sandbox))demo_exists(entry, entry.status()); // use cached status from directory entryfs::remove_all(sandbox);
}

输出：

"sandbox" exists
"sandbox/symlink" does not exist
"sandbox/file" exists

2.12、std::filesystem::equivalent

bool equivalent( const std::filesystem::path& p1,const std::filesystem::path& p2 );
bool equivalent( const std::filesystem::path& p1,const std::filesystem::path& p2,std::error_code& ec ) noexcept;

用于检查两个路径是否指向同一个文件系统实体
如果 p1 或者 p2 不存在，函数将报错。

注意：
判定相等的方式：两个路径指向的实体在同一个设备的同一个位置。对 POSIX 来说，在通过 stat() 获得的两个路径的 stat 结构体中，st_dev 与 st_ino 是对应相等的。

另外，同一个文件或文件夹的所有硬链接是等价的，同一个文件系统中的符号链接与其 target 之间是等价的。

案例：

#include <cstdint>
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{// hard link equivalencyfs::path p1 = ".";fs::path p2 = fs::current_path();if (fs::equivalent(p1, p2))std::cout << p1 << " is equivalent to " << p2 << '\n';// symlink equivalencyfor (const fs::path lib : {"/lib/libc.so.6", "/lib/x86_64-linux-gnu/libc.so.6"}){try{p2 = lib.parent_path() / fs::read_symlink(lib);}catch (std::filesystem::filesystem_error const& ex){std::cout << ex.what() << '\n';continue;}if (fs::equivalent(lib, p2))std::cout << lib << " is equivalent to " << p2 << '\n';}
}

输出：

"." is equivalent to "/var/tmp/test"
filesystem error: read_symlink: No such file or directory [/lib/libc.so.6]
"/lib/x86_64-linux-gnu/libc.so.6" is equivalent to "/lib/x86_64-linux-gnu/libc-2.23.so"

2.13、std::filesystem::file_size

std::uintmax_t file_size( const std::filesystem::path& p );
std::uintmax_t file_size( const std::filesystem::path& p,std::error_code& ec ) noexcept;

当 p 不存在时，函数报错；

案例：

#include <cmath>
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;struct HumanReadable
{std::uintmax_t size{};private:friend std::ostream& operator<<(std::ostream& os, HumanReadable hr){int o{};double mantissa = hr.size;for (; mantissa >= 1024.; mantissa /= 1024., ++o);os << std::ceil(mantissa * 10.) / 10. << "BKMGTPE"[o];return o ? os << "B (" << hr.size << ')' : os;}
};int main(int, char const* argv[])
{fs::path example = "example.bin";fs::path p = fs::current_path() / example;std::ofstream(p).put('a'); // create file of size 1std::cout << example << " size = " << fs::file_size(p) << '\n';fs::remove(p);p = argv[0];std::cout << p << " size = " << HumanReadable{fs::file_size(p)} << '\n';try{std::cout << "Attempt to get size of a directory:\n";[[maybe_unused]] auto x_x = fs::file_size("/dev");}catch (fs::filesystem_error& e){std::cout << e.what() << '\n';}for (std::error_code ec; fs::path bin : {"cat", "mouse"}){bin = "/bin"/bin;if (const std::uintmax_t size = fs::file_size(bin, ec); ec)std::cout << bin << " : " << ec.message() << '\n';elsestd::cout << bin << " size = " << HumanReadable{size} << '\n';}
}

输出：

"example.bin" size = 1
"./a.out" size = 22KB (22512)
Attempt to get size of a directory:
filesystem error: cannot get file size: Is a directory [/dev]
"/bin/cat" size = 50.9KB (52080)
"/bin/mouse" : No such file or directory

2.14、std::filesystem::hard_link_count

std::uintmax_t hard_link_count( const std::filesystem::path& p );
std::uintmax_t hard_link_count( const std::filesystem::path& p,std::error_code& ec ) noexcept;

返回 p 的硬链接数量

案例：

#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{// On a POSIX-style filesystem, each directory has at least 2 hard links:// itself and the special member pathname "."fs::path p = fs::current_path();std::cout << "Number of hard links for current path is "<< fs::hard_link_count(p) << '\n';// Each ".." is a hard link to the parent directory, so the total number// of hard links for any directory is 2 plus number of direct subdirectoriesp = fs::current_path() / ".."; // Each dot-dot is a hard link to parentstd::cout << "Number of hard links for .. is "<< fs::hard_link_count(p) << '\n';
}

输出：

Number of hard links for current path is 2
Number of hard links for .. is 3

2.15、std::filesystem::last_write_time

std::filesystem::file_time_type last_write_time( const std::filesystem::path& p );
std::filesystem::file_time_type last_write_time( const std::filesystem::path& p,std::error_code& ec ) noexcept;
void last_write_time( const std::filesystem::path& p,std::filesystem::file_time_type new_time );
void last_write_time( const std::filesystem::path& p,std::filesystem::file_time_type new_time,std::error_code& ec ) noexcept;

返回最近一次修改的时间

案例：

#include <chrono>
#include <filesystem>
#include <format>
#include <fstream>
#include <iostream>using namespace std::chrono_literals;int main()
{auto p = std::filesystem::temp_directory_path() / "example.bin";std::ofstream{p.c_str()}.put('a'); // create filestd::filesystem::file_time_type ftime = std::filesystem::last_write_time(p);std::cout << std::format("File write time is {}\n", ftime);// move file write time 1 hour to the futurestd::filesystem::last_write_time(p, ftime + 1h);// read back from the filesystemftime = std::filesystem::last_write_time(p);std::cout << std::format("File write time is {}\n", ftime);std::filesystem::remove(p);
}

输出：

File write time is 2023-09-04 19:33:24.702639224
File write time is 2023-09-04 20:33:24.702639224

2.16、std::filesystem::permissions

void permissions( const std::filesystem::path& p,std::filesystem::perms prms,std::filesystem::perm_options opts = perm_options::replace );
void permissions( const std::filesystem::path& p,std::filesystem::perms prms,std::error_code& ec ) noexcept;
void permissions( const std::filesystem::path& p,std::filesystem::perms prms,std::filesystem::perm_options opts,std::error_code& ec );

修改文件权限
在设置 prms 与 opts 参数时，有以下效果：

• 如果 opts 为 perm_options::replace，文件权限将被设为 prms & std::filesystem::perms::mask；
• 如果 opts 为 perm_options::add，文件权限将被设为 status(p).permissions() | (prms & perms::mask)；
• 如果 opts 为 perm_options::remove，文件权限将被设为 status(p).permissions() & ~(prms & perms::mask)

opts 仅能被设为 replace、add 与 remove 中的一个。

案例：

#include <filesystem>
#include <fstream>
#include <iostream>void demo_perms(std::filesystem::perms p)
{using std::filesystem::perms;auto show = [=](char op, perms perm){std::cout << (perms::none == (perm & p) ? '-' : op);};show('r', perms::owner_read);show('w', perms::owner_write);show('x', perms::owner_exec);show('r', perms::group_read);show('w', perms::group_write);show('x', perms::group_exec);show('r', perms::others_read);show('w', perms::others_write);show('x', perms::others_exec);std::cout << '\n';
}int main()
{std::ofstream("test.txt"); // create filestd::cout << "Created file with permissions: ";demo_perms(std::filesystem::status("test.txt").permissions());std::filesystem::permissions("test.txt",std::filesystem::perms::owner_all | std::filesystem::perms::group_all,std::filesystem::perm_options::add);std::cout << "After adding u+rwx and g+rwx:  ";demo_perms(std::filesystem::status("test.txt").permissions());std::filesystem::remove("test.txt");
}

输出：

Created file with permissions: rw-r--r--
After adding u+rwx and g+wrx:  rwxrwxr--

2.17、std::filesystem::read_symlink

std::filesystem::path read_symlink( const std::filesystem::path& p );
std::filesystem::path read_symlink( const std::filesystem::path& p,std::error_code& ec );

返回符号链接指向的目标路径

案例：

#include <filesystem>
#include <iostream>namespace fs = std::filesystem;int main()
{for (fs::path p : {"/usr/bin/gcc", "/bin/cat", "/bin/mouse"}){std::cout << p;fs::exists(p) ?fs::is_symlink(p) ?std::cout << " -> " << fs::read_symlink(p) << '\n' :std::cout << " exists but it is not a symlink\n" :std::cout << " does not exist\n";}
}

输出：

"/usr/bin/gcc" -> "gcc-5"
"/bin/cat" exists but it is not a symlink
"/bin/mouse" does not exist

2.18、std::filesystem::remove, std::filesystem::remove_all

bool remove( const std::filesystem::path& p );
bool remove( const std::filesystem::path& p, std::error_code& ec ) noexcept;
std::uintmax_t remove_all( const std::filesystem::path& p );
std::uintmax_t remove_all( const std::filesystem::path& p, std::error_code& ec );

删除文件或者文件夹

第一个函数在处理文件夹时，仅能处理空的；如果想删除文件夹及其所有内容，应该使用第二个函数

注意：
在 POSIX 系统中，相当于在执行 unlink 与 rmdir

在 Windows 中，在执行 DeleteFileW 与 RemoveDirectoryW

案例：

#include <cstdint>
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{fs::path tmp{std::filesystem::temp_directory_path()};std::filesystem::create_directories(tmp / "abcdef/example");std::uintmax_t n{fs::remove_all(tmp / "abcdef")};std::cout << "Deleted " << n << " files or directories\n";
}

输出：

Deleted 2 files or directories

2.19、std::filesystem::rename

void rename( const std::filesystem::path& old_p,const std::filesystem::path& new_p );
void rename( const std::filesystem::path& old_p,const std::filesystem::path& new_p,std::error_code& ec ) noexcept;

移动或者依据指定的 old_p 与 new_p 对文件系统对象进行重命名。

• 如果 old_p 不是文件夹，那么 new_p 就必须为下面几种情况：
  • 与 old_p 相同的文件，或者是它的硬链接：函数啥也不干；
  • 已存在：函数中，首先将 new_p 删除，然后将 new_p 链到 old_p 所指向的文件，最后将 old_p 解连。
  • 该文件不存在，但文件所在的文件夹存在：函数进行正常的移动操作；
• 如果 old_p 是文件夹，那 new_p 为下面中的几种：
  • 与 old_p 相同的文件夹，或者是它的硬链接：函数啥也不干；
  • 已经存在：正常的移动操作，与前面 old_p 是文件的对应情况类似；
  • 不存在，且不以文件夹分隔符结尾，且其父文件夹存在：与前面的移动操作类似，不再赘述。
• 操作符号链接：rename 改变的只是符号链接的名称，不是目标对象的。如果 new_p 是一个已经存在的符号链接，那在该函数将把它删除。

以下三种情况中，函数会执行失败：

• new_p 以 . 或者 .. 结尾；
• new_p是一个不存在的文件夹，且以文件夹分隔符结尾；
  old_p 是一个文件夹，且为 new_p 的某个上级目录。

案例：

#include <filesystem>
#include <fstream>
namespace fs = std::filesystem;int main()
{std::filesystem::path p = std::filesystem::current_path() / "sandbox";std::filesystem::create_directories(p / "from");std::ofstream{ p / "from/file1.txt" }.put('a');std::filesystem::create_directory(p / "to");//  fs::rename(p / "from/file1.txt", p / "to/"); // error: "to" is a directoryfs::rename(p / "from/file1.txt", p / "to/file2.txt"); // OK//  fs::rename(p / "from", p / "to"); // error: "to" is not emptyfs::rename(p / "from", p / "to/subdir"); // OKstd::filesystem::remove_all(p);
}

2.20、std::filesystem::resize_file

void resize_file( const std::filesystem::path& p,std::uintmax_t new_size );
void resize_file( const std::filesystem::path& p,std::uintmax_t new_size,std::error_code& ec ) noexcept;

修改常规文件 p 的大小。

如果文件尺寸比新尺寸大，多出来的那部分会被舍弃；

如果文件尺寸比新尺寸小，则文件尺寸将增加，且增加的那部分用 0 填充。

注意：
对支持稀疏文件的系统，增加文件尺寸并不会增加其在文件系统中所占的空间：仅仅在非零数值被写入到文件的时候，其占用的空间才会增加。

案例：
通过在剩余空间中创建稀疏文件来说明

#include <filesystem>
#include <fstream>
#include <iostream>
#include <locale>int main()
{auto p = std::filesystem::temp_directory_path() / "example.bin";std::ofstream{p}.put('a');std::cout.imbue(std::locale{"en_US.UTF8"});std::cout << "File size:  " << std::filesystem::file_size(p) << '\n'<< "Free space: " << std::filesystem::space(p).free << '\n';std::filesystem::resize_file(p, 64*1024); // resize to 64 KBstd::cout << "File size:  " << std::filesystem::file_size(p) << '\n'<< "Free space: " << std::filesystem::space(p).free << '\n';std::filesystem::remove(p);
}

输出：

File size:  1
Free space: 42,954,108,928
File size:  65,536
Free space: 42,954,108,928

2.21、std::filesystem::space

std::filesystem::space_info space( const std::filesystem::path& p );
std::filesystem::space_info space( const std::filesystem::path& p,std::error_code& ec ) noexcept;

判定 p 所在文件系统的空间信息。其行为类似于 POSIX 的 statvfs。

返回值类型中，设定值的方式与 POSIX 结构体 statvfs 的对应关系为：

• space_info.capacity 将设定为 f_blocks * f_frsize；
• space_info.free 将设定为 f_bfree * f_frsize；
• space_info.available 将设定为 f_bavail * f_frsize；
• 无法判断的就设为 static_cast<std::uintmax_t>(-1)

注意：
space_info.available 可能比 space_info.free 小。

案例：

#include <cstdint>
#include <filesystem>
#include <iostream>std::uintmax_t disk_usage_percent(const std::filesystem::space_info& si,bool is_privileged = false) noexcept
{if (constexpr std::uintmax_t X(-1);si.capacity == 0 || si.free == 0 || si.available == 0 ||si.capacity == X || si.free == X || si.available == X)return 100;std::uintmax_t unused_space = si.free, capacity = si.capacity;if (!is_privileged){const std::uintmax_t privileged_only_space = si.free - si.available;unused_space -= privileged_only_space;capacity -= privileged_only_space;}const std::uintmax_t used_space{capacity - unused_space};return 100 * used_space / capacity;
}void print_disk_space_info(auto const& dirs, int width = 14)
{(std::cout << std::left).imbue(std::locale("en_US.UTF-8"));for (const auto s : {"Capacity", "Free", "Available", "Use%", "Dir"})std::cout << "│ " << std::setw(width) << s << ' ';for (std::cout << '\n'; auto const& dir : dirs){std::error_code ec;const std::filesystem::space_info si = std::filesystem::space(dir, ec);for (auto x : {si.capacity, si.free, si.available, disk_usage_percent(si)})std::cout << "│ " << std::setw(width) << static_cast<std::intmax_t>(x) << ' ';std::cout << "│ " << dir << '\n';}
}int main()
{const auto dirs = {"/dev/null", "/tmp", "/home", "/proc", "/null"};print_disk_space_info(dirs);
}

输出：

│ Capacity       │ Free           │ Available      │ Use%           │ Dir            
│ 84,417,331,200 │ 42,732,986,368 │ 40,156,028,928 │ 50             │ /dev/null
│ 84,417,331,200 │ 42,732,986,368 │ 40,156,028,928 │ 50             │ /tmp
│ -1             │ -1             │ -1             │ 100            │ /home
│ 0              │ 0              │ 0              │ 100            │ /proc
│ -1             │ -1             │ -1             │ 100            │ /null

2.22、std::filesystem::status, std::filesystem::symlink_status

std::filesystem::file_status status( const std::filesystem::path& p );
std::filesystem::file_status status( const std::filesystem::path& p,std::error_code& ec ) noexcept;
std::filesystem::file_status symlink_status( const std::filesystem::path& p );
std::filesystem::file_status symlink_status( const std::filesystem::path& p,std::error_code& ec ) noexcept;

前两个函数用于确定 p 指定的文件系统对象的类型与属性

• 如果 p 是常规文件，函数返回 file_status(file_type::regular, prms)；
• 如果 p 是文件夹，函数返回 file_status(file_type::directory, prms)；
• 如果 p 是块文件，函数返回 file_status(file_type::block, prms)；
• 如果 p 是字符文件，函数返回 file_status(file_type::character, prms)；
• 如果 p 是 fifo 或 pipo 文件，函数返回 file_status(file_type::fifo, prms)；
• 如果 p 是 socket 文件，函数返回 file_status(file_type::socket, prms)；
• 如果 p 是 implementation-defined 文件类型，函数返回 file_status(file_type::A, prms)，其中 A 是那种类型的 implementation-defined file_type 常数；
• 如果 p 不存在，函数返回 file_status(file_type::not_found)；
• 如果 p 存在，但无法确定文件的属性，函数返回 file_status(file_type::unknown)；
• 如果 p 存在，但出错，函数返回 file_status(file_type::none)；
• 其他情况，函数返回 file_status(file_type::unknown, prms)；

后两个函数与前两个的功能基本相同，但额外多一个功能：

• 如果 p 是符号链接，函数返回 file_status(file_type::symlink)

案例：

#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>namespace fs = std::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 kindsfs::create_directory("sandbox");fs::create_directory("sandbox/dir");std::ofstream{"sandbox/file"}; // create regular filefs::create_symlink("file", "sandbox/symlink");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);// demo different status accessorsfor (auto it{fs::directory_iterator("sandbox")}; it != fs::directory_iterator(); ++it)demo_status(*it, it->symlink_status()); // use cached status from directory entrydemo_status("/dev/null", fs::status("/dev/null")); // direct calls to statusdemo_status("/dev/sda", fs::status("/dev/sda"));demo_status("sandbox/no", fs::status("/sandbox/no"));// cleanup (prefer std::unique_ptr-based custom deleters)close(fd);fs::remove_all("sandbox");
}

输出：

"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

2.23、std::filesystem::temp_directory_path

为临时文件返回一个临时路径

注意：
在 POSIX 系统中，该路径是通过环境变量 TMPDIR、TMP、TEMP 以及 TEMPDIR 指定的，如果这些变量没有被设定，则返回默认的路径 /tmp；
在 Windows 中，路径是通过函数 GetTempPath 给定的。

path temp_directory_path();
path temp_directory_path( std::error_code& ec );

案例：

#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;int main()
{std::cout << "Temp directory is " << fs::temp_directory_path() << '\n';
}

输出：

Temp directory is "C:\Windows\TEMP\"

3、文件类型

is_block_file	判断指定的路径是否为 block 设备
is_character_file	判断指定的路径是否为 character 设备
is_directory	判断指定的路径是否为文件夹
is_empty	判断指定的文件或文件夹是否为空
is_fifo	判断指定的路径是否为命名管道
is_other	判断指定的参数是否为 other 文件
is_regular_file	判断指定的参数是否为常规文件
is_socket	判断指定的参数是否为命名的 IPC socket
is_symlink	判断指定的参数是否为符号链接
status_known	检查文件状态是否已知

3.1、std::filesystem::is_block_file

定义于 <filesystem>

检查给定的文件状态或路径是否对应于块特殊文件，如 Linux 上的 /dev/sda 或 /dev/loop0

第一个函数等效于 s.type() == file_type::block

后两个函数等效于 is_block_file(status(p)) 与 is_block_file(status(p, ec))

bool is_block_file( std::filesystem::file_status s ) noexcept;
bool is_block_file( const std::filesystem::path& p );
bool is_block_file( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例：

#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>namespace fs = std::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 kindsfs::create_directory("sandbox");fs::create_directory("sandbox/dir");std::ofstream{"sandbox/file"}; // create regular filefs::create_symlink("file", "sandbox/symlink");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);// demo different status accessorsfor (auto it{fs::directory_iterator("sandbox")}; it != fs::directory_iterator(); ++it)demo_status(*it, it->symlink_status()); // use cached status from directory entrydemo_status("/dev/null", fs::status("/dev/null")); // direct calls to statusdemo_status("/dev/sda", fs::status("/dev/sda"));demo_status("sandbox/no", fs::status("/sandbox/no"));// cleanup (prefer std::unique_ptr-based custom deleters)close(fd);fs::remove_all("sandbox");
}

输出：

"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

3.2、std::filesystem::is_character_file

定义于 <filesystem>

第一个函数等效于 s.type() == file_type::character

后两个函数等效于 is_character_file(status(p)) 与 is_character_file(status(p, ec))

bool is_character_file( std::filesystem::file_status s ) noexcept;
bool is_character_file( const std::filesystem::path& p );
bool is_character_file( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例见 std::filesystem::is_block_file

3.3、std::filesystem::is_directory

定义于 <filesystem>

第一个函数等效于 s.type() == file_type::directory

后两个函数等效于 is_directory(status(p)) 与 is_directory(status(p, ec))

bool is_directory( std::filesystem::file_status s ) noexcept;
bool is_directory( const std::filesystem::path& p );
bool is_directory( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例见 std::filesystem::is_block_file

3.4、std::filesystem::is_empty

定义于 <filesystem>

bool is_empty( const std::filesystem::path& p );
bool is_empty( const std::filesystem::path& p, std::error_code& ec );

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

第一个函数在底层系统 API 错误上抛出 std::filesystem::filesystem_error，构建时将 p 作为第一个路径参数，将系统错误代码作为错误代码参数。

如果系统 API 调用失败，第二个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例：

#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iostream>int main()
{namespace fs = std::filesystem;const fs::path tmp_dir{fs::temp_directory_path()};std::cout << std::boolalpha<< "Temp dir: " << tmp_dir << '\n'<< "is_empty(): " << fs::is_empty(tmp_dir) << '\n';const fs::path tmp_name{tmp_dir / std::tmpnam(nullptr)};std::cout << "Temp file: " << tmp_name << '\n';std::ofstream file{tmp_name.string()};std::cout << "is_empty(): " << fs::is_empty(tmp_name) << '\n';file << "cppreference.com";file.flush();std::cout << "is_empty(): " << fs::is_empty(tmp_name) << '\n'<< "file_size(): " << fs::file_size(tmp_name) << '\n';file.close();fs::remove(tmp_name);
}

输出：

Temp dir: "/tmp"
is_empty(): false
Temp file: "/tmp/fileCqd9DM"
is_empty(): true
is_empty(): false
file_size(): 16

3.5、std::filesystem::is_fifo

定义于 <filesystem>

第一个函数等效于 s.type() == file_type::fifo

后两个函数等效于 is_fifo(status(p)) 与 is_fifo(status(p, ec))

bool is_fifo( std::filesystem::file_status s ) noexcept;
bool is_fifo( const std::filesystem::path& p );
bool is_fifo( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例见 std::filesystem::is_block_file

3.6、std::filesystem::is_other

定义于 <filesystem>

第一个函数等效于 exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)

后两个函数等效于 is_other(status(p)) 与 is_other(status(p, ec))

bool is_other( std::filesystem::file_status s ) noexcept;
bool is_other( const std::filesystem::path& p );
bool is_other( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

3.7、std::filesystem::is_regular_file

定义于 <filesystem>

第一个函数等效于 s.type() == file_type::regular

后两个函数等效于 is_regular_file(status(p)) 与 is_regular_file(status(p, ec))

bool is_regular_file( std::filesystem::file_status s ) noexcept;
bool is_regular_file( const std::filesystem::path& p );
bool is_regular_file( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例见 std::filesystem::is_block_file

3.8、std::filesystem::is_socket

定义于 <filesystem>

第一个函数等效于 s.type() == file_type::socket

后两个函数等效于 is_socket(status(p)) 与 is_socket(status(p, ec))

bool is_socket( std::filesystem::file_status s ) noexcept;
bool is_socket( const std::filesystem::path& p );
bool is_socket( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例见 std::filesystem::is_block_file

3.9、std::filesystem::is_symlink

定义于 <filesystem>

第一个函数等效于 s.type() == file_type::symlink

第二和第三个函数等效于 is_symlink(symlink_status(p)) 与 is_symlink(symlink_status(p, ec))

bool is_symlink( std::filesystem::file_status s ) noexcept;
bool is_symlink( const std::filesystem::path& p );
bool is_symlink( const std::filesystem::path& p, std::error_code& ec ) noexcept;

异常：
如果内存分配失败，任何未标记为 noexcept 的重载函数都可能引发 std::bad_alloc；

如果系统 API 调用失败，后两个函数会将 std::error_code& 参数设置为系统 API 错误代码；如果未出现错误，则执行 ec.clear()。

案例见 std::filesystem::is_block_file

3.10、std::filesystem::status_known

定义于 <filesystem>

与 s.type() != file_type::none 相同，用于判断给定的 file_status 是否已知

bool status_known( std::filesystem::file_status s ) noexcept;

注意：
不管名称如何，该函数都会检查文件状态 file_type::none（即发生错误），而不是 file_type::unknown（即文件存在，但无法确定其类型）。