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 fs::create_directories(destination) to ensure the destination directory exists.
• We iterate over each entry in the source directory using fs::recursive_directory_iterator.
• We check if the current entry is a directory using fs::is_directory(entry.status()).
• We calculate the relative path of the current directory from the source directory using fs::relative.
• We construct the new directory path in the destination and create the directory using fs::create_directories.

This method effectively copies the directory structure without copying any files. It uses fs::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.