How do I use std::filesystem for paths and operations in C++?

The std::filesystem library in C++ provides a powerful interface for working with file systems and paths. It allows you to create, manipulate, and traverse file system paths and directories in a platform-independent manner. Here’s how you can use this library for various operations:

Basics of std::filesystem

To use the std::filesystem library, you need to include the header:

#include <filesystem> #include <iostream> namespace fs = std::filesystem; int main() { // Creating a path fs::path p{"example_directory"}; // Creating a directory if (fs::create_directory(p)) { std::cout << "Directory created: " << p.string() << std::endl; } else { std::cout << "Directory already exists or failed to create." << std::endl; } // Checking if the path exists if (fs::exists(p)) { std::cout << "Path exists: " << p.string() << std::endl; } // Iterating through the directory for (const auto& entry : fs::directory_iterator(p)) { std::cout << "Found file: " << entry.path() << std::endl; } // Removing the directory fs::remove(p); std::cout << "Directory removed: " << p.string() << std::endl; return 0; }

This example shows how to create a directory, check for its existence, iterate through it, and finally remove it. The std::filesystem library simplifies many common tasks associated with file and directory manipulation.


Keywords: std::filesystem C++ file system directory operations path manipulation file handling

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?