实现一个工具：通过符号链接减少重复文件，从而控制文件夹大小

很多工具以不同的方式对数据进行压缩。其中最著名的文件压缩算法/格式就是ZIP和RAR。这种工具通过减少文件内部冗余，从而减少文件的大小。

将文件压缩成压缩包外，另一个非常简单的减少磁盘使用率的范式就是删除重复的文件。本节中，我们将实现一个小工具，其会对目录进行递归。递归中将对文件内容进行对比，如果找到相同的文件，我们将对其中一个进行删除。所有删除的文件则由一个符号链接替代，该链接指向目前唯一存在的文件。这种方式可以不通过压缩对空间进行节省，同时对所有的数据能够进行保存。

How to do it…

本节中，将实现一个小工具用来查找那些重复的文件。我们将会删除其中一个重复的文件，并使用符号链接的方式对其进行替换，这样就能减小文件夹的大小。

Note：

为了对系统数据进行备份，我们将使用STL函数对文件进行删除。一个简单的拼写错误就可能会删除很多并不想删除的文件。

  1. 包含必要的头文件，并声明所使用的命名空间：

    1. #include <iostream>
    2. #include <fstream>
    3. #include <unordered_map>
    4. #include <filesystem>
    6. using namespace std;
    7. using namespace filesystem;

  2. 为了查找重复的文件，我们将构造一个哈希表，并对将文件哈希值与其第一次产生的地址相对应。最好的方式就是通过哈希算法，对文件计算出一个MD5或SHA码。为了保证例子的简洁，我们将会把文件读入一个字符串中，然后使用hash函数计算出对应的哈希值：

    1. static size_t hash_from_path(const path &p)
    2. {
    3.     ifstream is {p.c_str(),
    4.         ios::in | ios::binary};
    5.     if (!is) { throw errno; }
    7.     string s;
    9.     is.seekg(0, ios::end);
    10.     s.reserve(is.tellg());
    11.     is.seekg(0, ios::beg);
    13.     s.assign(istreambuf_iterator<char>{is}, {});
    15.     return hash<string>{}(s);
    16. }

  3. 然后，我们会实现一个哈希表，并且删除重复的文件。其会对当前文件夹和其子文件夹进行遍历：

    1. static size_t reduce_dupes(const path &dir)
    2. {
    3.     unordered_map<size_t, path> m;
    4.     size_t count {0};
    6.     for (const auto &entry :
    7.          recursive_directory_iterator{dir}) {

  4. 对于每个文件入口，我们都会进行检查，当其是文件夹时就会跳过。对于每一个文件，我们都会产生一个哈希值，并且尝试将其插入哈希表中。当哈希表已经包含有相同的哈希值，这也就意味着有文件重复了。并且插入操作会终止，try_emplace所返回的第二个值就是false:

    1.     const path p {entry.path()};
    3.     if (is_directory(p)) { continue; }
    5.     const auto &[it, success] =
    6.         m.try_emplace(hash_from_path(p), p);

  5. try_emplace的返回值将告诉我们，该键是否是第一次插入的。这样我们就能找到重复的，并告诉用户文件有重复的，并将重复的进行删除。删除之后，我们将为重复的文件创建符号链接：

    1.     if (!success) {
    2.         cout << "Removed " << p.c_str()
    3.              << " because it is a duplicate of "
    4.              << it->second.c_str() << '\n';
    6.         remove(p);
    7.         create_symlink(absolute(it->second), p);
    8.         ++count;
    9.     }

  6. 对文件系统进行插入后，我们将会返回重复文件的数量：

    1.     }
    3.     return count;
    4. }

  7. 主函数中，我们会对用户在命令行中提供的目录进行检查。

    1. int main(int argc, char *argv[])
    2. {
    3.     if (argc != 2) {
    4.         cout << "Usage: " << argv[0] << " <path>\n";
    5.         return 1;
    6.     }
    8.     path dir {argv[1]};
    10.     if (!exists(dir)) {
    11.         cout << "Path " << dir << " does not exist.\n";
    12.         return 1;
    13.     }

  8. 现在我们只需要对reduce_dupes进行调用，并打印出有多少文件被删除了：

    1.     const size_t dupes {reduce_dupes(dir)};
    3.     cout << "Removed " << dupes << " duplicates.\n";
    4. }

  9. 编译并运行程序，输出中有一些看起来比较复杂的文件。程序执行之后，我会使用du工具来检查文件夹的大小，并证明这种方法是有效的。

    1. $ du -sh dupe_dir
    2. 1.1Mdupe_dir
    4. $ ./dupe_compress dupe_dir
    5. Removed dupe_dir/dir2/bar.jpg because it is a duplicate of
    6. dupe_dir/dir1/bar.jpg
    7. Removed dupe_dir/dir2/base10.png because it is a duplicate of
    8. dupe_dir/dir1/base10.png
    9. Removed dupe_dir/dir2/baz.jpeg because it is a duplicate of
    10. dupe_dir/dir1/baz.jpeg
    11. Removed dupe_dir/dir2/feed_fish.jpg because it is a duplicate of
    12. dupe_dir/dir1/feed_fish.jpg
    13. Removed dupe_dir/dir2/foo.jpg because it is a duplicate of
    14. dupe_dir/dir1/foo.jpg
    15. Removed dupe_dir/dir2/fox.jpg because it is a duplicate of
    16. dupe_dir/dir1/fox.jpg
    17. Removed 6 duplicates.
    19. $ du -sh dupe_dir
    20. 584Kdupe_dir

How it works…

使用create_symlink函数在文件系统中链接一个文件，指向另一个地方。这样就能避免重复的文件出现，也可以使用create_hard_link设置一些硬链接。硬链接和软连接相比，有不同的技术含义。有些格式的文件系统可能不支持硬链接，或者是使用一定数量的硬链接，指向相同的文件。另一个问题就是，硬链接没有办法让两个文件系统进行链接。

不过，除开实现细节，使用create_symlink或create_hard_link时，会出现一个明显的错误。下面的几行代码中就有一个bug。你能很快的找到它吗？

  1. path a {"some_dir/some_file.txt"};
  2. path b {"other_dir/other_file.txt"};
  3. remove(b);
  4. create_symlink(a, b);

在程序执行的时候，不会发生任何问题，不过符号链接将失效。符号链接将错误的指向some_dir/some_file.txt。正确指向的地址应该是/absolute/path/some_dir/some_file.txt或../some_dir/some_file.txt。create_symlink使用正确的绝对地址，可以使用如下写法：

  1. create_symlink(absolute(a), b);

Note：

create_symlink不会对链接进行检查

There’s more…

可以看到，哈希函数非常简单。为了让程序没有多余的依赖，我们采用了这种方式。

我们的哈希函数有什么问题呢？有两个问题：

  • 会将一个文件完全读入到字符串中。如果对于很大的文件来说，这将是一场灾难。
  • C++ 中的哈希函数hash<string>可能不是这样使用的。

要寻找一个更好的哈希函数时，我们需要找一个快速、内存友好、简单的，并且保证不同的文件具有不同的哈希值，最后一个需求可能是最关键的。因为我们使用哈希值了判断两个文件是否一致，当我们认为两个文件一致时，但哈希值不一样，就能肯定有数据受到了损失。

比较好的哈希算法有MD5和SHA(有变体)。为了让我们程序使用这样的函数，可能需要使用OpenSSL中的密码学API。