13. 文件系统

从早期版本开始，标准库就提供了处理文件的功能。通过诸如fstream之类的流，你可以打开文件、读取数据、写入字节以及执行许多其他操作。然而，此前缺少对整个文件系统进行操作的能力。例如，在C++14中，若要遍历目录、组合路径、删除目录或读取文件权限，你不得不使用一些第三方库。现在，随着C++17的发布，我们有了std::filesystem组件，在这方面向前迈出了一大步！

在本章中，你将学到：

• std::filesystem是如何被纳入标准的
• 基本类型和操作有哪些
• 如何操作路径
• 如何处理std::filesystem中的错误
• 如何遍历目录
• 如何创建新的目录和文件

文件系统概述

虽然标准库缺少一些重要功能，但你始终可以使用Boost库及其众多子库来完成相关工作。C++委员会认为Boost库非常重要，因此将其中的一些部分并入了标准库。例如，智能指针（尽管在C++11中通过移动语义得到了改进）、正则表达式、std::optional、std::any等等。

std::filesystem的情况也类似。

文件系统库直接借鉴了Boost文件系统库，Boost文件系统库自2003年（1.30版本）起就已可用。在C++的实现中，委员会还对该组件进行了扩展，使其支持非POSIX系统。该库最初以技术规范（Technical Specification，TS）的形式发布，经过长时间的改进和反馈后，最终被并入C++17标准。

该库位于<filesystem>头文件中，使用std::filesystem命名空间。

库的核心部分

文件系统库是标准库中相当重要的一部分。它定义了许多类型和数十个方法，还提供了许多自由函数。

下面我们来定义这个模块的核心元素：

• std::filesystem::path对象可用于操作路径，这些路径可以表示系统中存在或不存在的文件和目录。
• std::filesystem::directory_entry表示一个存在的路径，并包含额外的状态信息，如上次写入时间、文件大小或其他属性。
• 目录迭代器可用于遍历给定目录。该库提供了递归和非递归两种版本。
• 许多辅助函数，如获取路径信息、文件操作、权限设置、创建目录等等。

在下一节中，你将看到一个展示std::filesystem所有组成部分的示例。

示例

一开始我们不逐部分探究这个库，而是在接下来的内容中，通过一个示例来展示：递归显示给定目录中所有文件的基本信息。这能让你对该库有一个高层次的整体认识。

在Chapter Filesystem/filesystem_list_files.cpp文件中：

#include <filesystem>
#include <iomanip>
#include <iostream>

namespace fs = std::filesystem;

void DisplayDirectoryTree(const fs::path& pathToScan, int level = 0) {
    for (const auto& entry : fs::directory_iterator(pathToScan)) {
        const auto filenameStr = entry.path().filename().string();
        if (entry.is_directory()) {
            std::cout << std::setw(level * 3) << &quot;&quot; << filenameStr << '\n';
            DisplayDirectoryTree(entry, level + 1);
        } else if (entry.is_regular_file()) {
            std::cout << std::setw(level * 3) << &quot;&quot; << filenameStr
                      << &quot;, size &quot; << fs::file_size(entry) << &quot; bytes\n&quot;;
        } else {
            std::cout << std::setw(level * 3) << &quot;&quot; << &quot; [?]&quot; << filenameStr << '\n';
        }
    }
}

int main(int argc, char* argv[]) {
    try {
        const fs::path pathToShow{ argc >= 2 ? argv[1] : fs::current_path() };
        std::cout << &quot;listing files in the directory: &quot;
                  << fs::absolute(pathToShow).string() << '\n';
        DisplayDirectoryTree(pathToShow);
    } catch (const fs::filesystem_error& err) {
        std::cerr << &quot;filesystem error! &quot; << err.what() << '\n';
    } catch (const std::exception& ex) {
        std::cerr << &quot;general exception: &quot; << ex.what() << '\n';
    }
}

我们可以在临时路径D:\testlist上运行这个程序，得到如下输出：

• 在Windows上运行：

.\ListFiles.exe D:\testlist\
listing files in the directory: D:\testlist\
abc.txt, size 357 bytes
def.txt, size 430 bytes
ghi.txt, size 190 bytes
dirTemp
jkl.txt, size 162 bytes
mno.txt, size 1728 bytes
tempDir
abc.txt, size 174 bytes
def.txt, size 163 bytes
tempInner
abc.txt, size 144 bytes
mno.txt, size 1728 bytes
xyz.txt, size 3168 bytes

该应用程序递归列出文件，通过每一级缩进，你可以看到我们进入了新的目录。

• 在Linux（WSL上的Ubuntu 18.04）上运行：

fenbf@FEN-NODE:/mnt/f/wsl$ ./list_files.out testList/
listing files in the directory: /mnt/f/wsl/testList/
a.txt, size 965 bytes
b.txt, size 1667 bytes
c.txt, size 1394 bytes
d.txt, size 1408 bytes
directoryTemp
a.txt, size 1165 bytes
b.txt, size 1601 bytes
tempDir
a.txt, size 1502 bytes
b.txt, size 1549 bytes
x.txt, size 1487 bytes

现在让我们来分析这个示例的核心元素。

要使用这个库，我们必须包含相关的头文件。对于文件系统库来说，需要包含：

#include <filesystem>

所有的类型、函数和命名都位于std::filesystem命名空间中。为了方便使用，通常会创建一个命名空间别名：

namespace fs = std::filesystem;

这样我们就可以用fs::path来代替std::filesystem::path。让我们从main()函数开始分析，它是应用程序逻辑的起点。

程序从命令行获取一个可选参数。如果该参数为空，我们就使用当前系统路径：

const fs::path pathToShow{ argc >= 2 ? argv[1] : fs::current_path() };

pathToShow可以由字符串创建，如果argv[1]存在，就用它来创建；如果不存在，则使用current_path()，这是一个辅助自由函数，用于返回当前系统路径。

在接下来的两行（第28行和第29行），我们显示迭代的起始路径。absolute()函数会 “展开” 输入路径，如果需要，它会将相对路径转换为绝对路径。

应用程序的核心部分是DisplayDirectoryTree()函数。

在函数内部，我们使用directory_iterator来遍历目录并查找其他路径：

for (const auto& entry : fs::directory_iterator(pathToShow))

每次循环迭代都会得到一个directory_entry，我们需要对其进行检查。如果entry.is_directory()为真，我们就递归调用这个函数；如果是普通文件，则只显示一些基本信息。

可以看到，我们可以访问path和directory_entry的许多方法。例如，我们使用filename方法只返回路径中的文件名部分，以便显示 “树形” 结构。我们还调用fs::file_size来查询文件的大小。

通过这个小示例，现在让我们更深入地了解filesystem::path、filesystem::directory_entry、辅助的非成员函数以及错误处理。

路径对象

该库的核心部分是路径对象。它包含一个路径名，即构成路径名称的字符串。该对象不一定指向文件系统中存在的文件，路径甚至可能处于无效形式。

路径由以下元素组成：根名称（root-name）、根目录（root-directory）、相对路径（relative-path）。

• （可选）根名称：POSIX系统没有根名称。在Windows系统中，它通常是驱动器名称，如"C:"。
• （可选）根目录：用于区分相对路径和绝对路径。
• 相对路径：
  • 文件名（filename）
  • 目录分隔符（directory separator）
  • 相对路径（relative-path）

我们可以用以下图表来说明：

图 13.1 路径结构

该类实现了许多用于提取路径各部分的方法：

方法	描述
path::root_name() path::root_directory() path::root_path() path::relative_path() path::parent_path() path::filename() path::stem() path::extension()	返回路径的根名称 返回路径的根目录 返回路径的根路径 返回相对于根路径的路径 返回父路径的路径 返回文件名路径组件 返回文件名主干部分的路径组件 返回文件扩展名路径组件

如果某个给定元素不存在，上述函数将返回一个空路径。还有一些用于查询路径元素的方法：

查询名称	描述
path::has_root_path() path::has_root_name() path::has_root_directory() path::has_relative_path() path::has_parent_path() path::has_filename() path::has_stem() path::has_extension()	查询路径是否有根 查询路径是否有根名称 检查路径是否有根目录 检查路径是否有相对路径组件 检查路径是否有父路径 检查路径是否有文件名 检查路径是否有文件名主干部分的组件 检查路径是否有扩展名

我们可以使用上述所有方法，编写一个示例来展示给定路径的信息：Chapter Filesystem/filesystem_path_info.cpp

const filesystem::path testPath{...};

if (testPath.has_root_name())
    cout << "root_name() = " << testPath.root_name() << '\n ';
else
    cout << "no root-name\n ";

if (testPath.has_root_directory())
    cout << "root directory() = " << testPath.root_directory() << '\n ';
else
    cout << "no root-directory\n ";

if (testPath.has_root_path())
    cout << "root_path() = " << testPath.root_path() << '\n ';
else
    cout << "no root-path\n ";

if (testPath.has_relative_path())
    cout << "relative_path() = " << testPath.relative_path() << '\n ';
else
    cout << "no relative-path\n ";

if (testPath.has_parent_path())
    cout << "parent_path() = " << testPath.parent_path() << '\n ';
else
    cout << "no parent-path\n ";

if (testPath.has_filename())
    cout << "filename() = " << testPath.filename() << '\n ';
else
    cout << "no filename\n ";

if (testPath.has_stem())
    cout << "stem() = " << testPath.stem() << '\n ';
else
    cout << "no stem\n ";

if (testPath.has_extension())
    cout << "extension() = " << testPath.extension() << '\n ';
else
    cout << "no extension\n ";

对于像"C:\Windows\system.ini"这样的文件路径，输出如下：

root_name() = "C:"
root directory() = "\\" 
root_path() = "C:\\"
relative_path() = "Windows\\system.ini" 
parent_path() = "C:\\Windows"
filename() = "system.ini"
stem() = "system"
extension() = ".ini"

同样，在POSIX系统中，对于路径/usr/temp/abc.txt，输出如下：

no root-name
root directory() = "/"
root_path() = "/"
relative_path() = "usr/temp/abc.txt"
parent_path() = "/usr/temp"
filename() = "abc.txt"
stem() = "abc"
extension() = ".txt"

还有一个技巧，让你可以遍历路径对象的各个部分。std::filesystem::path为begin()和end()实现了重载，因此你可以在基于范围的for循环中使用它：

int i = 0;
for (const auto& part : testPath)
    cout << "path part: " << i++ << " = " << part << '\n ';

对于C:\Windows\system.ini的输出为：

path part: 0 = C:
path part: 1 = \
path part: 2 = Windows
path part: 3 = system.ini

路径操作

下面是路径类的其他重要方法表：

操作	描述
path::append()	在一个路径后追加另一个路径，并添加目录分隔符
path::concat()	连接路径，不添加目录分隔符
path::clear()	删除路径中的元素，使其变为空路径
path::remove_filename()	从路径中删除文件名部分
path::replace_filename()	替换路径中的单个文件名组件
path::replace_extension()	替换文件扩展名
path::swap()	交换两个路径
path::compare()	比较路径和另一个路径的词法表示，返回一个整数
path::empty()	检查路径是否为空

比较

路径类有几个重载运算符：==、!=、<、>、<=、>=，以及path::compare()方法，该方法返回一个整数值。

所有方法都使用路径的本地格式逐个元素进行比较。

fs::path p1 { "/usr/a/b/c" }; 
fs::path p2 { "/usr/a/b/c" }; 
assert(p1 == p2);
assert(p1.compare(p2) == 0);

p1 = "/usr/a/b/c";  
p2 = "/usr/a/b/c/d"; 
assert(p1 < p2);
assert(p1.compare(p2) < 0);

在Windows系统中，我们还可以测试路径中包含根元素的情况：

p1 = "C:/test";
p2 = "abc/xyz"; 
assert(p1 > p2);
assert(p1.compare(p2) > 0);

或者，同样在Windows系统中，测试路径格式不同的情况：

fs::path p3 { "/usr/a/b/c" }; 
fs::path p4 { "\\us r/a\\b/c" };
assert(p3 == p4);
assert(p3.compare(p4) == 0);

你可以在Chapter Filesystem/filesystem_compare.cpp中运行这些代码。

路径组合

我们有两个方法可用于组合路径：

• path::append() - 添加一个路径并带上目录分隔符。
• path::concat() - 仅添加“字符串”，不添加任何分隔符。

/、/=（追加）、+和+=（连接）运算符也提供了相同的功能。例如：

// 追加:
fs::path p1{"C:\\temp"};
p1 /= "user";
p1 /= "data";
cout << p1 << '\n ';

// 连接:
fs::path p2("C:\\temp\\");
p2 += "user"; 
p2 += "data";
cout << p2 << '\n ';

输出：

C:\temp\user\data
C:\temp\userdata

不过，追加路径有几条规则你需要注意。

例如，如果另一个路径是绝对路径，或者另一个路径有根名称且根名称与当前路径的根名称不同，那么追加操作将替换当前路径。

auto resW = fs::path{"foo"} / "D:\" ; 
auto resP = fs::path{"foo"} / "/bar"; 

在上述例子中，resW现在是"D:\"，resP现在是"/bar"。因为D:\和/bar都包含根元素。

流操作符

path类还实现了>>和<<操作符。

这些操作符使用std::quoted来保留正确的格式。这就是为什么示例中的路径显示有引号。

在Windows系统上，这还会导致运行时以原生格式输出路径时出现\\。例如在POSIX系统上：

fs::path p1{ "/usr/test/temp.xyz" }; 
std::cout << p1;

上述代码将输出/usr/test/temp.xyz。而在Windows系统上：

fs::path p1{ "usr/test/temp.xyz" };
fs::path p2{ "usr\\test\\temp.xyz" };
std::cout << p1 << '\n ' << p2; 

上述代码将输出：

"usr/test/temp.xyz"
"usr\\test\\temp.xyz"

路径格式与转换

文件系统库（filesystem library）是基于POSIX标准建模的（例如，所有基于Unix的系统都实现了POSIX标准），但它也适用于其他文件系统，比如Windows文件系统。因此，在以可移植的方式使用路径时，有一些事项需要注意。

首先是路径格式。我们有两种核心模式：

• 通用（generic） - 通用格式，即标准指定的格式（基于POSIX格式）。
• 原生（native） - 特定实现所使用的格式。

在POSIX系统中，原生格式与通用格式相同。但在Windows系统中，它们是不同的。

格式的主要区别在于，Windows使用反斜杠（\）而不是斜杠（/）。另外，Windows有根目录，比如C:、D:或其他盘符。

另一个重要方面是用于存储路径元素的字符串类型。在POSIX系统中是char（以及std::string），但在Windows系统中是wchar_t和std::wstring。path类型通过指定path::value_type和string_type（定义为std::basic_string<value_type>）来体现这些属性。

path类有几个方法，可以让你使用最匹配的格式。如果你想使用原生格式，可以使用：

操作	描述
path::c_str()	返回value_type*
path::native()	返回string_type&

还有许多方法可以转换原生格式：

操作	描述
path::string() path::wstring() path::u8string() path::u16string() path::u32string()	转换为string 转换为wstring 转换为u8string 转换为u16string 转换为u32string

由于Windows使用wchar_t作为路径的底层类型，因此你需要注意向char的“隐式”转换。

目录项与目录迭代

path类表示存在或不存在的文件或路径，而我们还有另一个更具体的对象：directory_entry对象。这个对象指向现有的文件和目录，通常借助文件系统迭代器来获取。

此外，鼓励实现缓存额外的文件属性，这样可以减少系统调用次数。

使用目录迭代器遍历路径

你可以使用两种可用的迭代器来遍历路径：

• directory_iterator - 在单个目录中迭代，是输入迭代器。
• recursive_directory_iterator - 递归迭代，是输入迭代器。

在这两种方法中，访问文件名的顺序是未指定的，每个目录项只会被访问一次。

如果在创建目录迭代器之后，文件或目录被删除或添加到目录树中，通过该迭代器是否能观察到这种变化是未指定的。

在这两种迭代器中，目录.和..会被跳过。

你可以使用以下模式遍历目录：

for (auto const & entry : fs::directory_iterator(pathToShow)) {
    ...
}

或者另一种方式，使用算法，你还可以在其中过滤路径：

std::filesystem::path inPath = /* GetInputPath() */;
std::vector<std::filesystem::directory_entry> outEntries;
std::filesystem::recursive_directory_iterator dirpos{ inPath };
std::copy_if(begin(dirpos), end(dirpos), std::back_inserter(outEntries),
    some_predicate);

some_predicate是一个谓词，它接受const directory_entry&，并根据给定的directory_entry对象是否符合我们的过滤条件返回true或false。所有符合条件的路径都会被压入outEntries向量中。有关此技术的用例，请参阅本章示例部分中的“使用正则表达式过滤文件”。另外，除了使用目录项的输出向量，你还可以使用路径向量，因为目录项可以转换为路径。

directory_entry方法

以下是directory_entry的方法列表：

操作	描述
directory_entry::assign()	替换条目内的路径，并调用refresh()来更新缓存的属性
directory_entry::replace_filename()	替换条目内的文件名，并调用refresh()来更新缓存的属性
directory_entry::refresh()	更新文件的缓存属性
directory_entry::path()	返回存储在条目中的路径
directory_entry::exists()	检查目录项是否指向现有的文件系统对象
directory_entry::is_block_file()	如果文件项是块设备文件，则返回true
directory_entry::is_character_file()	如果文件项是字符设备文件，则返回true
directory_entry::is_directory()	如果文件项是目录，则返回true
directory_entry::is_fifo()	如果文件项是命名管道，则返回true
directory_entry::is_other()	如果文件项是其他文件类型，则返回true
directory_entry::is_regular_file()	如果文件项是普通文件，则返回true
directory_entry::is_socket()	如果文件项是命名的IPC套接字，则返回true
directory_entry::is_symlink()	如果文件项是符号链接，则返回true
directory_entry::file_size()	返回目录项指向的文件的大小
directory_entry::hard_link_count()	返回指向该文件的硬链接数量
directory_entry::last_write_time()	获取或设置文件的最后写入时间
directory_entry::status()	返回此目录项指定的文件的状态
directory_entry::symlink_status()	返回此目录项指定的文件的符号链接状态

支持函数

到目前为止，我们已经介绍了文件系统的三个元素：path类、directory_entry和目录迭代器。该库还提供了一组非成员函数。

查询函数

函数	描述
filesystem::is_block_file()	检查给定路径是否指向块设备
filesystem::is_character_file()	检查给定路径是否指向字符设备
filesystem::is_directory()	检查给定路径是否指向目录
filesystem::is_empty()	检查给定路径是否指向空文件或空目录
filesystem::is_fifo()	检查给定路径是否指向命名管道
filesystem::is_other()	检查参数是否指向其他文件
filesystem::is_regular_file()	检查参数是否指向普通文件
filesystem::is_socket()	检查参数是否指向命名的IPC套接字
filesystem::is_symlink()	检查参数是否指向符号链接
filesystem::status_known()	检查文件状态是否已知
filesystem::exists()	检查路径是否指向现有的文件系统对象
filesystem::file_size()	返回文件的大小
filesystem::last_write_time()	获取或设置最后数据修改的时间

路径相关

函数名	描述
filesystem::absolute()	组合成绝对路径
filesystem::canonical(),<br/>weakly_canonical()	组合成规范路径
filesystem::relativeproximate()	组合成相对路径
filesystem::current_path()	返回或设置当前工作目录
filesystem::equivalent()	检查两个路径是否指向同一个文件系统对象

目录和文件管理

函数名	描述
filesystem::copy()	复制文件或目录
filesystem::copy_file()	复制文件内容
filesystem::copy_symlink()	复制符号链接
filesystem::create_directory(),<br/>filesystem::create_directories()	创建新目录
filesystem::create_hard_link()	创建硬链接
filesystem::create_symlink()	创建符号链接
filesystem::hard_link_count()	返回指向特定文件的硬链接数量
filesystem::permissions()	修改文件访问权限
filesystem::read_symlink()	获取符号链接的目标
filesystem::remove(),<br/>filesystem::remove_all()	删除单个文件或递归删除整个目录及其所有内容
filesystem::rename()	移动或重命名文件或目录
filesystem::resize_file()	通过截断或填充零来更改普通文件的大小
filesystem::space()	确定文件系统上的可用空闲空间
filesystem::status(),<br/>filesystem::symlink_status()	确定文件属性，检查符号链接目标
filesystem::temp_directory_path()	返回适合存放临时文件的目录

获取和显示文件时间

在C++17中，关于last_write_time()的值有一个不太方便的地方。

我们有一个自由函数和directory_entry中的一个方法。它们都返回file_time_type，目前定义为：

using file_time_type = std::chrono::time_point</*trivial-clock*/>; 

根据标准30.10.25节《头文件<filesystem>概述》：

trivial-clock是一种由实现定义的类型，它满足TrivialClock要求，并且能够表示和测量文件时间值。实现应确保file_time_type的分辨率和范围反映操作系统相关的文件时间值的分辨率和范围。

换句话说，它是与实现相关的。

例如，在GCC/Clang标准库（STL）中，文件时间是基于chrono::system_clock实现的，但在MSVC中，它是特定平台的时钟。

以下是关于Visual Studio中实现决策的更多详细信息：std::filesystem::file_time_type不便于转换为time_t 。

随着C++20引入std::chrono::file_clock以及时钟之间的转换例程，这种情况可能很快会得到改善。请参阅P0355 （已添加到C++20中）。

让我们看一些代码：

auto filetime = fs::last_write_time(myPath);
const auto toNow = fs::file_time_type::clock::now() - filetime;
const auto elapsedSec = duration_cast<seconds>(toNow).count();

上述代码提供了一种计算自上次更新以来经过的秒数的方法。然而，这不如显示实际日期有用。

在POSIX系统（GCC和Clang实现）上，你可以轻松地将文件时间转换为系统时钟时间，然后获得std::time_t：

auto filetime = fs::last_write_time(myPath);
std::time_t convfiletime = std::chrono::system_clock::to_time_t(filetime);
std::cout << "Updated: " << std::ctime(&convfiletime) << '\n ';

在MSVC上，上述代码无法编译。不过可以保证file_time_type可与接受FILETIME的原生操作系统函数一起使用。因此，我们可以编写以下代码来解决这个问题：

auto filetime = fs::last_write_time(myPath); 
FILETIME ft;
memcpy(&ft, &filetime, sizeof(FILETIME)); 
SYSTEMTIME stSystemTime;
if (FileTimeToSystemTime(&ft, &stSystemTime)) {
    // use stSystemTime.wYear, stSystemTime.wMonth, stSystemTime.wDay, ...
}

完整示例请参阅Chapter Filesystem/filesystem_list_files_info.cpp。

文件权限

在上面的表格中，你可能注意到了与文件权限相关的函数。主要有两个函数：

• std::filesystem::status()
• std::filesystem::permissions()

第一个函数返回file_status，其中包含有关文件类型及其权限的信息。

你可以使用第二个函数来修改文件权限，例如，将文件更改为只读。

文件权限（std::filesystem::perms）是一个枚举类（enum class），代表以下值：

名称	值（八进制）	POSIX宏	注释
none	0000		文件未设置任何权限
owner_read	0400	S_IRUSR	所有者的读权限
owner_write	0200	S_IWUSR	所有者的写权限
owner_exec	0100	S_IXUSR	所有者的执行/搜索权限
owner_all	0700	S_IRWXU	所有者的读、写、执行/搜索权限
group_read	0040	S_IRGRP	组的读权限
group_write	0020	S_IWGRP	组的写权限
group_exec	0010	S_IXGRP	组的执行/搜索权限
group_all	0070	S_IRWXG	组的读、写、执行/搜索权限
others_read	0004	S_IROTH	其他用户的读权限
others_write	0002	S_IWOTH	其他用户的写权限
others_exec	0001	S_IXOTH	其他用户的执行/搜索权限
others_all	0007	S_IRWXO	其他用户的读、写、执行/搜索权限
all	0777		owner_all | group_all | others_all
set_uid	04000	S_ISUID	执行时设置用户ID
set_gid	02000	S_ISGID	执行时设置组ID
sticky_bit	01000	S_ISVTX	依赖于操作系统
mask	07777		all | set_uid | set_gid | sticky_bit
unknown	0xFFFF		权限未知

下面这段简短的代码展示了如何打印文件权限：

Chapter Filesystem/filesystem_permissions.cpp
std::ostream& operator<< (std::ostream& stream, fs::perms p)
{
    stream << "owner: "
           << ((p & fs::perms::owner_read)  != fs::perms::none ? "r" : "-")
           << ((p & fs::perms::owner_write) != fs::perms::none ? "w" : "-")
           << ((p & fs::perms::owner_exec)  != fs::perms::none ? "x" : "-");
    stream << " group: "
           << ((p & fs::perms::group_read)  != fs::perms::none ? "r" : "-")
           << ((p & fs::perms::group_write) != fs::perms::none ? "w" : "-")
           << ((p & fs::perms::group_exec)  != fs::perms::none ? "x" : "-");
    stream << " others: "
           << ((p & fs::perms::others_read)  != fs::perms::none ? "r" : "-")
           << ((p & fs::perms::others_write) != fs::perms::none ? "w" : "-")
           << ((p & fs::perms::others_exec)  != fs::perms::none ? "x" : "-");
    return stream; 
}

你可以像这样使用上述operator<<的实现：

std::cout << "perms: " << fs::status("myFile.txt").permissions() << '\n ';

设置权限

要更改权限，可以使用以下代码：

std::cout << "after creation: " << fs::status(sTempName).permissions() << '\n '; 
fs::permissions(sTempName, fs::perms::owner_read, fs::perm_options::remove);
std::cout << "after change: " << fs::status(sTempName).permissions() << '\n ';

std::filesystem::permissions是一个函数，它接受一个路径，然后是一个标志和“操作”参数。

fs::perm_options有三种模式：

• replace - 你传递的权限标志将替换现有状态。这是该参数的默认值。
• add - 权限标志将与现有状态进行按位或运算。
• remove - 权限将被替换为取反后的参数与当前权限的按位与运算结果。
• nofollow - 权限将在符号链接本身上更改，而不是在它所解析到的文件上更改。

例如：

// 移除“所有者读”权限
fs::permissions(myPath, fs::perms::owner_read, fs::perm_options::remove);
// 添加“所有者读”权限
fs::permissions(myPath, fs::perms::owner_read, fs::perm_options::add);
// 替换并设置“所有者全部”权限：
fs::permissions(myPath, fs::perms::owner_all); // replace是默认参数

Windows注意事项

Windows不是POSIX系统，它不会将POSIX文件权限映射到自己的权限方案中。对于std::filesystem，它仅支持两种模式：只读和全部权限。

从微软文档的文件系统文档³中可知：

支持的值本质上是“readonly”和“all”。对于只读文件，所有*_write位都未设置。否则，设置“all”位（0777）。

因此，遗憾的是，如果你想在Windows上更改文件权限，选择有限。

错误处理与文件竞争

到目前为止，本章中的示例使用异常处理来报告错误。文件系统API还提供了输出错误代码的函数和方法重载。你可以决定是使用异常还是错误代码。

例如，对于file_size函数，我们有两个重载：

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

第二个重载可以这样使用：

const std::filesystem::path testPath("C:\test.txt");
std::error_code ec{};
auto size = std::filesystem::file_size(testPath, ec);
if (ec == std::error_code{})
    std::cout << "size: " << size << '\n ';
else
    std::cout << "error when accessing test file, size is: "
              << size << " message: " << ec.message() << '\n ';

file_size接受一个额外的输出参数error_code，如果发生错误，它会设置一个值。如果操作成功，那么ec将被默认初始化。

文件竞争

需要指出的是，当发生文件竞争时可能会出现未定义行为，这一点很重要。

从30.10.2.3节文件系统竞争行为可知：

如果对本库中函数的调用引发文件系统竞争，则行为未定义。

从30.10.9节文件系统竞争可知：

当多个线程、进程或计算机交错访问和修改文件系统中的同一对象时发生的情况。

示例

在本节中，我们将分析几个使用std::filesystem的示例。我们将从一个简单的例子开始——将文件内容加载到字符串中，然后探索创建目录，最后使用std::regex过滤文件名。

示例代码可在Chapter Filesystem/filesystem_list_files.cpp中找到，其扩展版本（展示文件时间和大小）位于Chapter Filesystem/filesystem_list_files_info.cpp中。

有关更多用例，你还可以阅读“如何并行化CSV读取器”这一章，其中std::filesystem是查找CSV文件的关键元素。

将文件加载到字符串中

第一个示例展示了一个很好的案例，我们利用std::filesystem中与大小相关的函数为文件内容构建一个缓冲区。

代码如下：

Chapter Filesystem/filesystem_load_string.cpp
[[nodiscard]] std::string GetFileContents(const fs::path& filePath) {
    std::ifstream inFile{ filePath, std::ios::in | std::ios::binary };
    if (!inFile)
        throw std::runtime_error("Cannot open " + filePath.string());
    const auto fsize = fs::file_size(filePath);
    if (fsize > std::numeric_limits<size_t>::max())
        throw std::runtime_error("file is too large to fit into size_t! "
                                 + filePath.string());
    std::string str(static_cast<size_t>(fsize), 0);
    inFile.read(str.data(), str.size());
    if (!inFile)
        throw std::runtime_error("Could not read the full contents from "
                                 + filePath.string());
    return str; 
}

在C++17之前，要获取文件大小，通常需要将文件指针重新定位到文件末尾，然后再次读取位置。例如：

ifstream testFile("test.file", ios::binary);
const auto begin = myfile.tellg();
testFile.seekg(0, ios::end);
const auto end = testFile.tellg();
const auto fsize =  (end-begin);

你也可以使用ios::ate标志打开文件，这样文件指针会自动定位到文件末尾。

然而，上述所有方法都需要打开文件，而使用std::filesystem，代码要短得多，我们只需要读取文件属性。

此外，std::filesystem技术所需的访问权限“更低”，因为你只需要父目录的读权限，无需“文件读”权限。

如果你使用std::filesystem::directory_entry方法，文件大小可能来自缓存。

创建目录

在第二个示例中，我们将创建N个目录，每个目录中包含M个文件。main()函数的核心部分如下：

Chapter Filesystem/filesystem_build_temp.cpp
const fs::path startingPath{ argc >= 2 ? argv[1] : fs::current_path() };
const std::string strTempName{ argc >= 3 ? argv[2] : "temp" };
const int numDirectories{ argc >= 4 ? std::stoi(argv[3]) : 4 };
const int numFiles{ argc >= 5 ? std::stoi(argv[4]) : 4 };
if (numDirectories < 0 || numFiles < 0)
    throw std::runtime_error("negative input numbers...");
const fs::path tempPath = startingPath / strTempName; 
CreateTempData(tempPath, numDirectories, numFiles);

以及CreateTempData()函数：

//Chapter Filesystem/filesystem_build_temp.cpp
std::vector<fs::path> GeneratePathNames(const fs::path& tempPath, unsigned num) {
    std::vector<fs::path> outPaths{ num, tempPath };
    for (auto& dirName : outPaths) {
        // use pointer value to generate unique name...
        const auto addr = reinterpret_cast<uintptr_t>(&dirName);
        dirName /= std::string(&quot;tt&quot;) + std::to_string(addr);
    }
    return outPaths;
}

void CreateTempFiles(const fs::path& dir, unsigned numFiles) {
    auto files = GeneratePathNames(dir, numFiles);
    for (auto& oneFile : files) {
        std::ofstream entry(oneFile.replace_extension(&quot;.txt&quot;));
        entry << &quot;Hello World&quot;;
    }
}

void CreateTempData(const fs::path& tempPath, unsigned numDirectories, unsigned numFiles) {
    fs::create_directory(tempPath);
    auto dirPaths = GeneratePathNames(tempPath, numDirectories);
    for (auto& dir : dirPaths) {
        if (fs::create_directory(dir)) {
            CreateTempFiles(dir, numFiles);
        }
    }
}

在CreateTempData()函数中，我们首先创建文件夹结构的根目录。然后在GeneratePathNames()函数中生成路径名，每个路径名都是根据指针地址构建的，这种方法应该能为我们提供一系列不错的唯一名称。当我们有了唯一路径的向量后，还会为文件生成另一个路径向量，在这个例子中，我们使用.txt扩展名。创建目录时使用fs::create_directory，而创建文件可以使用标准流对象。

如果我们使用以下参数运行应用程序：". temp 2 4"，它将创建以下目录结构：

temp
├── tt22325368
│   ├── tt22283456.txt, size 11 bytes
│   ├── tt22283484.txt, size 11 bytes
│   ├── tt22283512.txt, size 11 bytes
│   └── tt22283540.txt, size 11 bytes
└── tt22325396
    ├── tt22283456.txt, size 11 bytes
    ├── tt22283484.txt, size 11 bytes
    ├── tt22283512.txt, size 11 bytes
    └── tt22283540.txt, size 11 bytes

使用正则表达式过滤文件

本章的最后一个示例将使用自C++11起可用的std::regex来过滤文件名。

main()函数的核心部分如下：

Chapter Filesystem/filesystem_filter_files.cpp
const fs::path pathToShow{ argc >= 2 ? argv[1] : fs::current_path() };
const std::regex reg(argc >= 3 ? argv[2] : "");
auto files = CollectFiles(pathToShow); 
std::sort(files.begin(), files.end());
for (auto& entry : files) {
    const auto strFileName = entry.mPath.filename().string();
    if (std::regex_match(strFileName, reg))
        std::cout << strFileName << "\tsize: " << entry.mSize << '\n ';
}

该应用程序会递归地收集给定目录中的所有文件，之后，如果文件条目与正则表达式匹配，就会显示出来。

CollectFiles()函数使用递归目录迭代器查找所有文件，并构建每个文件的必要信息。在main()函数中，我们按文件大小对文件进行排序。

//Chapter Filesystem/filesystem_filter_files.cpp
struct FileEntry {
    fs::path mPath;
    uintmax_t mSize{0};

    static FileEntry Create(const fs::path& filePath) {
        return FileEntry{filePath, fs::file_size(filePath)};
    }

    friend bool operator<(const FileEntry& a, const FileEntry& b) noexcept {
        return a.mSize < b.mSize;
    }
};

std::vector<FileEntry> CollectFiles(const fs::path& inPath) {
    std::vector<fs::path> paths;

    if (fs::exists(inPath) && fs::is_directory(inPath)) {
        std::filesystem::recursive_directory_iterator dirpos{inPath};
        std::copy_if(begin(dirpos), end(dirpos), std::back_inserter(paths),
            [](const fs::directory_entry& entry) {
                return entry.is_regular_file();
            }
        );
    }

    std::vector<FileEntry> files(paths.size());
    std::transform(paths.cbegin(), paths.cend(), files.begin(), FileEntry::Create);
    return files;
}

在CollectFiles函数中，我们使用递归迭代器，然后使用std::copy_if仅过滤普通文件。之后，收集完文件后，我们创建FileEntry的输出向量。

FileEntry::Create()函数初始化对象并获取文件大小。

例如，如果我们使用以下参数运行应用程序"temp .*.txt"，我们将在目录中查找所有的txt文件。

.\FilterFiles.exe temp .*.txt
tt22283456.txt  size: 11
tt22283484.txt  size: 11
tt22283512.txt  size: 11
tt22283540.txt  size: 11
tt22283456.txt  size: 11
tt22283484.txt  size: 11
tt22283512.txt  size: 11
tt22283540.txt  size: 11

优化与代码清理

CollectFiles()函数会遍历一个目录，然后将普通文件的路径输出到一个向量中。之后，该函数会创建FileEntry对象，并将它们返回到另一个单独的向量中。

看起来，在扫描过程中，我们并没有充分利用filesystem::directory_entry对象的所有优势。例如，directory_entry::file_size成员方法会比自由函数filesystem::file_size快得多，因为directory_entry通常会将文件属性缓存在内存中。

另一个需要优化的地方是路径的临时向量。我们可以使用基于范围的for循环来跳过这一步。

以下是最终代码：

//Chapter Filesystem/filesystem_filter_files.cpp
std::vector<FileEntry> CollectFilesOpt(const fs::path& inPath) {
    std::vector<FileEntry> files;

    if (fs::exists(inPath) && fs::is_directory(inPath)) {
        for (const auto& entry : fs::recursive_directory_iterator{ inPath }) {
            if (entry.is_regular_file()) {
                files.push_back({ entry, entry.file_size() });
            }
        }
    }

    return files;
}

本章总结

在本章中，我们深入探讨了C++17最重要的新增内容之一：std::filesystem。你了解了该库的核心元素，包括路径类（path class）、目录项（directory_entry）和迭代器，以及许多辅助自由函数。

在整章内容中，我们还探索了大量示例，从诸如组合路径、获取文件大小、遍历目录等简单场景，到更复杂的场景，如使用正则表达式进行过滤或创建临时目录结构。

你现在应该已经掌握了关于std::filesystem的扎实知识，并且准备好自行探索该库。

std::filesystem的完整实现记录在论文P0218《为C++17采用文件系统技术规范 (opens new window)》中。还有其他一些更新，例如P0317《目录项缓存》 (opens new window)、P0430《非类POSIX操作系统上的文件系统库》 (opens new window)、P0492R2《C++17各国团体评论的决议》 (opens new window)、P0392《适配文件系统路径的string_view》 (opens new window)。

你可以在C++17草案N4687 (opens new window)的“文件系统”部分（30.10节）找到最终规范。也可以在这个在线地址timsong-cpp/filesystems (opens new window)中查看。

编译器支持

GCC/libstdc++

该库在8.0版本中被添加，见提交记录“实现C++17文件系统 (opens new window)”。自GCC 5.3起，你可以试用实验版本，即技术规范（TS）的实现版本。

从GCC 9.1开始，文件系统库与标准库的其他部分位于同一个二进制文件中，但在该版本之前，你必须使用-lstdc++fs进行链接。

要编译demo.cpp，你应该输入以下命令：

# GCC 9.1及以上版本：
g++ -std=c++17 -O2 -Wall -Werror demo.cpp
# GCC 9.1之前版本：
g++ -std=c++17 -O2 -Wall -Werror demo.cpp -lstdc++fs

Clang/libc++

对<filesystem>的支持在7.0版本中实现，你可以查看这个提交记录 (opens new window)。自Clang 3.9起，你可以开始试用实验版本，即技术规范的实现版本。

与GCC（在GCC 9.1之前）类似，你必须链接到libc++fs.a。

Visual Studio

<filesystem>的完整实现在Visual Studio 2017 15.7版本中添加。

在15.7版本之前，你可以在更早的版本中试用<experimental/filesystem>。实验性实现甚至在Visual Studio 2012中就已可用，并且在之后的每个版本中都逐步得到改进。

编译器支持总结

特性	GCC	Clang	MSVC
文件系统	8.0	7.0	VS 2017 15.7