To use the filesystem library of C 17, you need to use a compiler that supports C 17, including the header file, link the libstdc fs library (such as GCC requires -lstdc fs), and correctly handle path encoding and exceptions; 1. Use exists, is_regular_file, etc. to check the existence and type of files; 2. Use create_directory to create a single-level directory, create_directories to create multi-level directories; 3. Use directory_iterator to traverse the directory, and recursive_directory_iterator to traverse recursively; 4. Get the size through file_size, and combine chrono to convert the last_write_time printing time; 5. Use rename, remove, remove_all to perform rename and delete operations; 6. It is recommended to use the member functions and/operators of the path class to process cross-platform paths; it is recommended to use try-catch to catch filesystem_error exceptions to avoid narrow character Chinese path problems, and pay attention to the performance impact when traversing large directories. This library makes C file operations more modern, secure and cross-platform.

C 17 introduces the <filesystem></filesystem> library, a very practical standard library for handling file and directory operations. Before C 17, developers usually rely on platform-related APIs (such as POSIX or Windows APIs) or third-party libraries (such as Boost) to operate the file system. Now, std::filesystem provides a cross-platform, modern C-style interface.

To use std::filesystem you need:

• Use compilers that support C 17 (such as GCC 8, Clang 7, MSVC 15.7)
• Contains header file <filesystem></filesystem>
• Linking necessary system libraries (such as libstdc fs)

Enable filesystem library (compile configuration)

On GCC you may need to manually link stdc fs :

 g -std=c 17 your_file.cpp -lstdc fs

Clang and MSVC are usually automatically linked and do not require additional parameters.

Basic usage: a list of common functions

1. Check whether the file exists and determine the type

 #include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main() {
    fs::path p = "example.txt";

    if (fs::exists(p)) {
        std::cout << p << " exists.\n";

        if (fs::is_regular_file(p)) {
            std::cout << p << " is a normal file.\n";
        } else if (fs::is_directory(p)) {
            std::cout << p << " is a directory.\n";
        }
    } else {
        std::cout << p << " does not exist.\n";
    }

    return 0;
}

2. Create a directory

 if (fs::create_directory("new_folder")) {
    std::cout << "Directory creation was successful.\n";
} else {
    std::cout << "Directory already exists or failed to create.\n";
}

// Create multi-level directories (C 17 does not support directly, recursion or C 20 create_directories)
// So it is recommended to use:
fs::create_directories("dir/subdir/subsubdir"); // Can be created even if the parent directory does not exist

Note: create_directory() creates only single-layer directories, while create_directories() creates all missing parent directories.

3. Traverse the content of the directory

 fs::path dir = ".";

for (const auto& entry : fs::directory_iterator(dir)) {
    std::cout << entry.path() << "\n";
}

If you want to recursively traverse subdirectories, use recursive_directory_iterator :

 for (const auto& entry : fs::recursive_directory_iterator(dir)) {
    std::cout << entry.path() << "\n";
}

You can also filter file types:

 for (const auto& entry : fs::directory_iterator(dir)) {
    if (entry.is_regular_file()) {
        std::cout << "File: " << entry.path().filename() << "\n";
    } else if (entry.is_directory()) {
        std::cout << "Directory: " << entry.path().filename() << "\n";
    }
}

4. Obtain file information

 if (fs::is_regular_file(p)) {
    auto fsize = fs::file_size(p);
    std::cout << "File size: " << fsize << " Byte\n";

    auto time = fs::last_write_time(p);
    // Note: time is file_time_type, printing requires conversion (see below)
}

Printing timestamps is a little more complicated because file_time_type is a std::chrono type:

 #include <iomanip>

// Simplified time printing (convert to local time)
auto sctp = fs::last_write_time(p);
std::time_t cftime = std::chrono::system_clock::to_time_t(
    std::chrono::file_clock::to_sys(sctp)
);
std::cout << "Last modified time: " << std::put_time(std::localtime(&cftime), "%Y-%m-%d %H:%M:%S") << "\n";

Note: std::put_time may need to enable -std=c 20 in some compilers (such as older versions of GCC) to work properly.

5. File renaming and deletion

 fs::rename("old_name.txt", "new_name.txt");
fs::remove("unwanted_file.txt"); // Delete a single file fs::remove_all("some_directory"); // Delete the directory and its contents

6. Path Manipulation

fs::path is a core class that supports cross-platform path processing:

 fs::path p = "/home/user/documents/report.txt";

std::cout << "root path: " << p.root_path() << "\n"; // / or C:\
std::cout << "Parent directory: " << p.parent_path() << "\n"; // /home/user/documents
std::cout << "Filename: " << p.filename() << "\n"; // report.txt
std::cout << "Extension: " << p.extension() << "\n"; // .txt
std::cout << "No extension file name: " << p.stem() << "\n"; // report

// The splicing path fs::path p2 = "/home/user" / "documents" / "file.txt";
std::cout << "Split path: " << p2 << "\n";

The / operator is overloaded to securely splice the paths and avoid manual addition / or \ .

Practical tips and precautions

• Path string encoding : On Windows, it is recommended to use UTF-8-encoded strings, otherwise an error may occur. Avoid using narrow character Chinese paths (unless you know how to deal with wide characters).
• Exception handling : Most filesystem functions can throw exceptions, it is recommended to wrap it with try-catch:

 try {
    fs::create_directory("test_dir");
} catch (const fs::filesystem_error& e) {
    std::cerr << "File system error: " << e.what() << "\n";
}

• Performance Note : When traversing large directories, directory_iterator is lazy to evaluate, but frequent calls to status() or file_size() may affect performance.

Complete example: List all .cpp files in the current directory

 #include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main() {
    for (const auto& entry : fs::directory_iterator(".")) {
        if (entry.is_regular_file() && entry.path().extension() == ".cpp") {
            std::cout << entry.path().filename() << "\n";
        }
    }
    return 0;
}

Basically that's it. std::filesystem makes C file operation simple, secure and cross-platform. Although not as rich as Python's os.path or pathlib , it is already powerful enough in modern C projects.

Not complicated, but it is easy to ignore link libraries or time to deal with these details.

The above is the detailed content of C Filesystem library tutorial C 17. For more information, please follow other related articles on the PHP Chinese website!