std::filesystem:: recursive_directory_iterator

recursive_directory_iterator est un LegacyInputIterator qui itère sur les éléments directory_entry d'un répertoire, et, récursivement, sur les entrées de tous les sous-répertoires. L'ordre d'itération n'est pas spécifié, sauf que chaque entrée de répertoire n'est visitée qu'une seule fois.

Par défaut, les liens symboliques ne sont pas suivis, mais cela peut être activé en spécifiant l'option de répertoire follow_directory_symlink au moment de la construction.

Les noms de chemin spéciaux dot et dot-dot sont ignorés.

Si le recursive_directory_iterator signale une erreur ou est avancé au-delà de la dernière entrée de répertoire du répertoire de niveau supérieur, il devient égal à l'itérateur construit par défaut, également appelé itérateur de fin. Deux itérateurs de fin sont toujours égaux, déréférencer ou incrémenter l'itérateur de fin est un comportement indéfini.

Si un fichier ou un répertoire est supprimé ou ajouté à l'arborescence de répertoires après la création de l'itérateur de répertoire récursif, il n'est pas spécifié si le changement serait observé via l'itérateur.

Si la structure de répertoire contient des cycles, l'itérateur de fin peut être inaccessible.

Types membres

Fonctions membres

Fonctions non membres

De plus, operator== et operator!= sont (jusqu'à C++20) operator== est (depuis C++20) fournis comme requis par LegacyInputIterator .

Il n'est pas spécifié si operator!= est fourni car il peut être synthétisé à partir de operator== , et (depuis C++20) si un opérateur d'égalité est membre ou non-membre.

Spécialisations d'assistance

Ces spécialisations pour recursive_directory_iterator en font un borrowed_range et une view .

Notes

Un recursive_directory_iterator contient généralement un pointeur à comptage de références (pour satisfaire la sémantique de copie superficielle des LegacyInputIterator ) vers un objet d'implémentation, qui contient :

• un conteneur (tel que std::vector ) d'itérateurs de répertoire non récursifs directory_iterator s qui forme la pile de récursion,
• le compteur de profondeur de récursion (accessible avec depth() ),
• les options de répertoire utilisées lors de la construction (accessibles avec options() ),
• le drapeau de récursion en attente (accessible avec recursion_pending() , peut être combiné avec les options de répertoire pour économiser de l'espace).

Exemple

#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
namespace fs = std::filesystem;
int main()
{
    std::filesystem::current_path(std::filesystem::temp_directory_path());
    std::filesystem::create_directories("sandbox/a/b");
    std::ofstream("sandbox/file1.txt");
    std::filesystem::create_symlink("a", "sandbox/syma");
    // Itérer explicitement sur les éléments std::filesystem::directory_entry
    auto entry_length{3UZ};
    for (const fs::directory_entry& dir_entry :
            fs::recursive_directory_iterator("sandbox"))
    {
        std::cout << dir_entry << '\n';
        if (auto l{dir_entry.path().string().length()}; entry_length < l)
            entry_length = l;
    }
    std::cout << std::string(entry_length + 2, '-') << '\n';
    // Itérer sur les éléments std::filesystem::directory_entry en utilisant `auto`
    for (auto const& dir_entry : fs::recursive_directory_iterator("sandbox"))
        std::cout << dir_entry << '\n';
    std::filesystem::remove_all("sandbox");
}

"sandbox/syma"
"sandbox/file1.txt"
"sandbox/a"
"sandbox/a/b"
-------------------
"sandbox/syma"
"sandbox/file1.txt"
"sandbox/a"
"sandbox/a/b"

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi