std::filesystem in C 17 provides cross-platform file and directory operation interfaces. ① Create a single-layer directory using create_directory(), and create_directories() using multi-layer directory; ② Remove() can be used to delete directories or files (only empty directories or files), and remove_all() can be used to delete recursively; ③ Use directory_iterator to traverse the directory, recursive_directory_iterator, and type can be judged by is_regular_file() or is_directory(); ④ Check the file status to exists(), is_regular_file(), is_directory() and file_size(), but file_size() will throw exceptions when the path does not exist; ⑤ Use the / operator for path stitching, and parsing paths can be used by parent_path(), filename(), and stem() and extension(); ⑥ Pay attention to the differences in exception handling and platform when using it. It is recommended to use the error_code parameter to avoid crashes.

Using C's std::filesystem to handle file and directory operations is indeed much more convenient than before. It officially entered the standard library since C 17 and no longer needs to rely on platform-related APIs. If you have used Boost.Filesystem before, you will find that its interface is almost the same, just changed its name.

Below are some common uses and precautions, which are suitable for use directly in daily development.

Create and delete directories

Creating directories is a common requirement, such as a cache directory needs to be generated when the program is running.
std::filesystem::create_directory() can create single-layer directories:

 fs::create_directory("my_folder");

If you want to create a multi-layer directory (such as a/b/c ), you need to use create_directories() , and this function will automatically help you create the middle path.

If you delete, use remove() or remove_all() , which can recursively delete the entire directory tree:

• fs::remove("empty_dir") : Only empty directories or files can be deleted.
• fs::remove_all("dir_with_files") : Forced delete, including all contents inside.

Traversing the contents of the directory

You can use directory_iterator to traverse the directory, which will list all files and subdirectories in the current directory:

 for (const auto& entry : fs::directory_iterator("my_folder")) {
    std::cout << entry.path() << std::endl;
}

If you want to recursively traverse subdirectories, you can use recursive_directory_iterator , which will go down layer by layer. Note that the type can be determined by is_regular_file() or is_directory() .

Some small details:

• By default, the content pointed to by symbolic links will not be traversed.
• You can control whether to skip the point file ( . and .. ) through parameters.

Check whether the file exists, obtain size and other information

You can use these functions to quickly determine the state of a path:

• fs::exists(path) : Check if it exists
• fs::is_regular_file(path) : Is it a normal file?
• fs::is_directory(path) : Is it a directory
• fs::file_size(path) : Get file size (unit bytes)

It should be noted that if the path does not exist, calling file_size() will throw an exception. In order to avoid this, it is recommended to judge the existence first.

For example:

 if (fs::exists("data.txt") && fs::is_regular_file("data.txt")) {
    std::cout << "File size: " << fs::file_size("data.txt") << " bytes\n";
}

Path stitching and analysis

Just use the / operator to splice the path, which is very intuitive:

 fs::path p = "C:/Users" / "name" / "Documents" / "notes.txt";

It also provides easy extraction of various parts of the path:

• p.parent_path() : parent directory
• p.filename() : file name (including extension)
• p.stem() : Part without extension
• p.extension() : extension

For example, for notes.txt :

• stem() is notes
• extension() is .txt

Basically these common operations are. The design of std::filesystem is more intuitive, but there are some pitfalls that need to be paid attention to. For example, some functions will throw exceptions by default when failing. It is best to add try-catch when using it, or pass an error_code parameter to avoid crashes.

In addition, although it is cross-platform, some behaviors may vary slightly under different systems, especially when it comes to permissions, symbolic links, and hidden files.

After using it well, you will find that it is much easier to write now than before, manually spelling strings and calling the system API.

The above is the detailed content of Using std::filesystem in C. For more information, please follow other related articles on the PHP Chinese website!