Discussion :

[prop215]

Bonjour,

Dans une appli, j'ai besoin de parcourir des dossiers. J'ai donc suivi un tutoriel C++. J'ai cependant un problème : j'ai besoin de parcourir les sous-répertoires d'un répertoire père. J'ai donc fait une fonction itérative :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
void analyseDossier(DIR* rep, char* chemin)
{
    struct dirent* fichierLu;
    while ((fichierLu = readdir(rep)) != NULL)
    {
        cout << "\nFichier lu : " << fichierLu->d_name << "\tPosition : " << telldir(rep) << endl;
 
        if (isDir(chemin))
        {
            DIR* repEnfant;
            char* cheminEnfant = strcat(chemin, fichierLu->d_name);
            repEnfant = opendir(cheminEnfant);
            analyseDossier (repEnfant, cheminEnfant);
        }
    }
}

Donc cette fonction appelle isDir() qui renvoie vrai ou faux si c'est un dossier ou non (même critère que dans le tuto : s'il y a un point on considère que c'est un fichier avec une extension) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
bool isDir(char* chemin)
{
    char* test = NULL;
    test = strchr(chemin,'.');
 
    if (test == NULL)
    {
        cout << "\nC'est un dossier." << endl;
        return true;
    }
    else
    {
        cout << test << endl;
        cout << "\n c'est un fichier." << endl;
        return false;
    }
}

Le problème, c'est qu'elle me renvoie toujours true et donc, quand l'appli revient dans analyseDossier(), elle essaye d'ouvrir un fichier comme un dossier (d'où une erreur segmentation fault).

Merci d'avance pour votre aide

[6-MarViN]

Deja, le parcours d'un file system se fait generalement en recursif (chose que tu fait d'ailleur), et non pas en iteratif.

Ensuite ton affirmation 'si y'a un point alors c'est un ficher' est fausse. Un fichier peut tres bien ne pas avoir d'extension. Il faut que tu fasse un stat sur le fichier et que tu verifie son mode.

En assumant que tu travaille sur un systeme GNU/Linux, ta fonction isDir() renvoie toujours vrai car tu as oublie de prendre en compte les dossiers '.' et '..' respectivement le dossier courant et le dossier parent, ce qui fait que tu part en recursion infinie, ce qui fait exploser la stack.

[r0d]

Bonjour,

Je ne sais pas ce que c'est que cette méthode , mais le mieux pour ce genre de choses c'est tout de même d'utiliser boost::filesystem

[3DArchi]

Salut,

Comme le dit R0d, Boost.FileSystem est ton ami

Pour frimer, avec Boost.FileSystem et Boost.Filter (et un peu de std::bind, std::ptr_fn) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <iostream>
#include <algorithm>
#include <boost/filesystem.hpp>
#include <boost/iterator/filter_iterator.hpp>
#include <functional>
 
namespace bfs = boost::filesystem;
 
template<class command_t_>
void parse(bfs::path path_, command_t_ cmd_)
{
    // gestion des répertoires :
    std::for_each(
        boost::make_filter_iterator<bool (*)( const bfs::path & ph )>(
            bfs::is_directory
            ,bfs::directory_iterator(path_),bfs::directory_iterator()
        )
        ,boost::make_filter_iterator<bool (*)( const bfs::path & ph )>(
            bfs::is_directory
            ,bfs::directory_iterator(path_),bfs::directory_iterator()
        )
        ,std::bind2nd(std::ptr_fun(parse<command_t_>),cmd_)
    );
    // gestion des fichiers :
    std::for_each(
        boost::make_filter_iterator<bool (*)( const bfs::path & ph )>(
            bfs::is_regular_file
            ,bfs::directory_iterator(path_),bfs::directory_iterator()
        )
        ,boost::make_filter_iterator<bool (*)( const bfs::path & ph )>(
            bfs::is_regular_file
            ,bfs::directory_iterator(path_),bfs::directory_iterator()
        )
        ,cmd_
    );
}
 
void dump_file(bfs::path const& path_)
{
   assert(bfs::is_regular_file(path_));
    std::cout<<path_<<"\n";
}
 
 
int main(int argc, char* argv[])
{
  parse(argv[1],dump_file);
  return 0;
}

Un peu plus simple avec les lambda C++0x :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <algorithm>
#include <boost/filesystem.hpp>
 
namespace bfs = boost::filesystem;
 
template<class command_t_>
void parse(bfs::path path_, command_t_ cmd_)
{
   std::for_each(
      bfs::directory_iterator(path_),bfs::directory_iterator()
      ,[cmd_](bfs::path item_)
      {
         if(bfs::is_directory(item_))
         {
         }
         else
         if(bfs::is_regular_file(item_))
         {
            cmd_(item_);
         }
   }
 
   );
}
 
void dump_file(bfs::path const& path_)
{
   assert(bfs::is_regular_file(path_));
    std::cout<<path_<<"\n";
}
 
 
int main(int argc, char* argv[])
{
  parse(argv[1],dump_file);
  return 0;
}