Copying Directory Structures using std::filesystem

To copy a directory structure without copying files using std::filesystem, you can use the copy() function with the copy_options::directories_only flag.

This flag ensures that only the directory structure is copied, ignoring the files within those directories. Here's an example demonstrating how to copy a directory structure:

1#include <filesystem>
2#include <iostream>
3namespace fs = std::filesystem;
4
5void copy_directory_structure(
6  const fs::path &source,
7  const fs::path &destination
8) {
9  try {
10    fs::create_directories(destination); 
11    for (const auto &entry :
12      fs::recursive_directory_iterator(source)) {
13      if (fs::is_directory(entry.status())) { 
14        fs::path relative_path =
15          fs::relative(entry.path(), source); 
16        fs::path new_directory =
17          destination / relative_path; 
18        fs::create_directories(new_directory); 
19        std::cout << "Created directory: "
20          << new_directory << '\n';
21      }
22    }
23  } catch (fs::filesystem_error &e) {
24    std::cerr << e.what() << '\n';
25  }
26}
27
28int main() {
29  fs::path source{R"(c:\test)"}; 
30  fs::path destination{R"(c:\test_copy)"}; 
31  copy_directory_structure(source, destination);
32}

1Created directory: c:\test_copy\subdir

In this example:

• We define source as the path to the directory we want to copy and destination as the path where we want to copy the structure.
• We use create_directories(destination) to ensure the destination directory exists.
• We iterate over each entry in the source directory using recursive_directory_iterator.
• We check if the current entry is a directory using is_directory(entry.status()).
• We calculate the relative path of the current directory from the source directory using std::filesystem::relative.
• We construct the new directory path in the destination and create the directory using create_directories().

This method effectively copies the directory structure without copying any files. It uses recursive_directory_iterator to traverse the directory tree and create corresponding directories in the destination.

If you want to exclude certain directories from being copied, you can add additional checks within the loop to filter out unwanted directories.

This approach ensures that only the directory structure is copied, which can be useful when you need to replicate a directory hierarchy without duplicating the files.