Fonction récursive pour la liste de tous les fichiers dans les sous répertoires

Je suis en train d'écrire une fonction qui renvoie une liste de tous les fichiers du dossier actuel et tous ses sous-dossiers. J'ai écrit ce code:

#include <iostream>
#include <dirent.h>
#include <cstring>

using namespace std;

int main() {
   DIR* dir; dirent* pdir;
   //From my workspace
   dir=opendir(".");     
   while (pdir=readdir(dir)) {
       if(/**********This pdir is a directory**********/) {
           /**********RECURSIVE CALL SHOULD BE HERE**********/
           cout<<pdir->d_name<<endl;
       }
   }
   closedir(dir);
   return 0;
}

J'ai cherché dans google et je ne sais pas comment faire:

  • Vérifier si le courant pdir est un répertoire
  • Aller à l'intérieur du répertoire et d'effectuer l'appel récursif sur elle

En attendant j'ai tout avoir sous la main car je ne sais toujours pas quels sont les arguments de la fonction récursive doit avoir.

Un indice?

InformationsquelleAutor Maroun | 2012-10-29
  1. 5

    Isoler ce code dans une procédure qui prend le chemin du répertoire de base comme un paramètre, vous pouvez effectuer l'appel récursif. Il doit être quelque chose comme

    void recursive_file_list(const char * directory)
{
    //...
}

    Ensuite, pour vérifier si la pdir vous obtenu est un répertoire, vous avez deux itinéraires:

    • vous pouvez vérifier si pdir->d_type==DT_DIR; cela vous donne cette information immédiatement, mais il n'est pas portable (POSIX ne précise pas l'existence de la d_type membre); de plus, il n'est pas pris en charge par tous les systèmes de fichiers, de sorte que vous pouvez obtenir DT_UNKNOWN. Si vous voulez suivre les liens symboliques, vous avez à effectuer des contrôles supplémentaires aussi si vous obtenez DT_LNK. Dans ces cas, vous devez revenir à lstat (voir le point ci-dessous);
    • vous pouvez à la place utiliser de façon portable lstat pour obtenir des informations sur chaque fichier, en vérifiant notamment la st_mode champ de struct stat.
    • Même si d_type existe, vous devez avoir le secours de stat parce que le système de fichiers n'est pas nécessaire de remplir d_type même si le système d'exploitation prend en charge. Aussi, d_type valeurs sont pas masques de bits, vous voulez juste (pdir->d_type == DT_DIR).
    • correct, fixe.
    InformationsquelleAutor Matteo Italia
  2. 9

    Ici est une version à l'aide de la proposition d'une norme de système de fichiers de la bibliothèque:

    #include <iostream>
#include <filesystem>

using namespace std;
using namespace std::tr2::sys;

void main()
{   
  for (recursive_directory_iterator i("."), end; i != end; ++i) 
    if (!is_directory(i->path()))
      cout << i->path().filename() << "\n";
}
    InformationsquelleAutor Paul Jurczak
  3. 8

    À moins que votre but est d'apprendre comment écrire une fonction récursive, vous préférerez peut-être cette simple boucle basée sur Coup de pouce.Système de fichiers:

    #include "boost/filesystem.hpp"
#include <iostream>

int main () {
  for ( boost::filesystem::recursive_directory_iterator end, dir("./");
    dir != end; ++dir ) {
    //std::cout << *dir << "\n";  //full path
    std::cout << dir->path().filename() << "\n"; //just last bit
  }
}

    Ou même le seul appel de la fonction:

    std::copy(
  boost::filesystem::recursive_directory_iterator("./"),
  boost::filesystem::recursive_directory_iterator(),
  std::ostream_iterator<boost::filesystem::directory_entry>(std::cout, "\n"));
    • Un problème mineur avec votre exemple est qu'il donne la liste des répertoires en plus de fichiers - voir ma réponse à exclure des répertoires.
    InformationsquelleAutor Robᵩ
  4. 3

    Mon approche en C++11:

    #include <string>
#include <functional>
#include <dirent.h>

void listFiles(const std::string &path, std::function<void(const std::string &)> cb) {
    if (auto dir = opendir(path.c_str())) {
        while (auto f = readdir(dir)) {
            if (!f->d_name || f->d_name[0] == '.') continue;
            if (f->d_type == DT_DIR) 
                listFiles(path + f->d_name + "/", cb);

            if (f->d_type == DT_REG)
                cb(path + f->d_name);
        }
        closedir(dir);
    }
}

    Utilisation:

    listFiles("my_directory/", [](const std::string &path) {
    std::cout << path << std::endl;
});
    • Une erreur: !f->d_name toujours true.
    InformationsquelleAutor AdrianEddy
  5. 1

    Chemin ressemble à /your_path/. Pour la recherche dans les dossiers cachés, vous devez ajouter un troisième paramètre true. 

    #include <dirent.h>
#include <vector>
#include <cstring>    

void GetReqDirs(const std::string& path, std::vector<string>& files,const bool showHiddenDirs = false){
    DIR *dpdf;
    struct dirent *epdf;
    dpdf = opendir(path.c_str());
    if (dpdf != NULL){
        while ((epdf = readdir(dpdf)) != NULL){
            if(showHiddenDirs ? (epdf->d_type==DT_DIR && string(epdf->d_name) != ".." && string(epdf->d_name) != "." ) : (epdf->d_type==DT_DIR && strstr(epdf->d_name,"..") == NULL && strstr(epdf->d_name,".") == NULL ) ){
                GetReqDirs(path+epdf->d_name+"/",files, showHiddenDirs);
            }
            if(epdf->d_type==DT_REG){
                files.push_back(path+epdf->d_name);
            }
        }
    }
    closedir(dpdf);
}
    InformationsquelleAutor Victor
  6. 0

    Vous pouvez vérifier si il n'y a pas de "." dans la chaîne.

    if(strstr(pdir->d_name,".") != NULL)
    • . est parfaitement bien le nom de répertoire de la partie.
    InformationsquelleAutor user1594121
  7. 0

    À l'aide de C++17 recursive_directory_iterator il devient aussi concis que:

    void ls_recursive(const std::filesystem::path& path) {
    for(const auto& p: std::filesystem::recursive_directory_iterator(path)) {
        if (!std::filesystem::is_directory(p)) {
            std::cout << p.path() << '\n';
        }
    }
}

    Avec exemple de sortie:

    "/home/user/prj/rust/stack/Cargo.toml"
"/home/user/prj/rust/stack/.gitignore"
"/home/user/prj/rust/stack/src/main.rs"
"/home/user/prj/rust/stack/.git/config"
    InformationsquelleAutor Leśny Rumcajs