[C] Structure de données à utiliser pour le parcours de dossier

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : [C] Structure de données à utiliser pour le parcours de dossier

Ydalb

In Crêpes n' Cidre I Trust!

Bonjour à tous.

J'ai un programme à faire qui à pour but de parcourir un répertoire et ses sous-répertoires, pour ensuite afficher divers résultats (Nombre de fichiers par utilisateur, leur taille totale cumulées, etc).

Je suis en train de réfléchir à la structure de données à utiliser, mais je n'arrive pas à voir comment je pourrais stocker toutes ses informations.

J'aimerais procéder ainsi :
- Parcours de tous les fichiers (dossier et sous-dossiers)
- A chaque fichier, je stock l'utilisateur (l'owner), la taille du fichier et le nom du fichier bien sûr
- Je parse le résultat suivant ce qui m'est demander

Pour la structure à utiliser, j'étais parti sur une liste par dossier, seulement j'ai un problème :
- Je vais parcourir le premier dossier, créer une liste comprenant un nombre de noeuds égal au nombre de fichier dans le dossier. Quid des sous-dossiers ? Il me faudrait alors une liste de liste. Mais quid des sous-sous-dossiers ?

Je sais pas si vous voyez mon soucis, mais je ne vois pas trop quelle genre de structure 'dynamique' adopter pour un tel projet ...

Merci par avance pour vos réponses.
:hello:

---------------
:o

Publicité

olivthill

Peut-être qu'il serait plus simple d'afficher les résultats au fur et à mesure plutôt que de les stocker.

Sinon, la structure est celle d'une arborescence, c'est-à-dire :

Code :

struct _node {
char name[256]; // Nom du dossier ou du fichier, sans le chemin
char type; // Dossier ou fichier
struct _node *parent_node; // pointeur vers le noeud père (ou on pourrait faire un pointeur vers le fils)
struct _node *next_node; // pointeur vers le noeud suivant au même niveau
}

h3bus

Troll Inside

Je rajouterais un pointeur child_node, sur le premier élément fils dans le cas d'un répertoire.

---------------
sheep++

Ydalb

In Crêpes n' Cidre I Trust!

Merci pour vos réponses.

J'ai donc utilisé ta structure de données (Tree ?) en rajoutant un pointeur vers le premier élément fils.

Code :

typedef struct Leaf
{
struct File *file;
struct Leaf *parent; // pointeur vers le noeud père
struct Leaf *next; // pointeur vers le noeud suivant au même niveau
struct Leaf *child; // pointeur vers le fils
} Leaf;
typedef struct Tree
{
Leaf *first;
} Tree;

Ma structure File est toute simple :

Code :

typedef struct File
{
char *name;
char *owner;
int type; // 0: dossier, 1: fichier régulier
long long size;
} File;

J'ai créé une méthode d'insertion qui va bien :

Code :

void addLeaf (Tree *tree, Leaf *parent, Leaf *child)
{
child->child = NULL; // Dans tous les cas, le node qu'on ajoute n'a pas de fils ni de suivant
child->next = NULL;
if (parent == NULL) // Premier élément du Tree
{
tree->first = child;
child->parent = NULL;
}
else if (parent->child == NULL) // On ajoute un fils à un parent qui n'a aucun fils
{
parent->child = child;
child->parent = parent;
}
else // Le parent a au moins un fils, on ajoute 'child' a la suite
{
Leaf *current = parent->child;
Leaf *prev = parent->child;
while (current != NULL)
{
prev = current;
current = current->next;
}
prev->next = child;
child->parent = parent;
}
}
void addFile (Tree *tree, Leaf *parent, File f) // Méthode qui fait appel à addLeaf ensuite
{
File *file;
file = malloc (sizeof (File));
(*file) = f;
Leaf *child;
child = malloc (sizeof (Leaf));
child->file = file;
addLeaf (tree, parent, child);
}

Maintenant j'essaie de parcourir mon arbre. Un parcours en profondeur me suffirait. Après diverses recherches, il semblerait qu'une fonction récursive soit nécessaire. Voici ce à quoi j'arrive :

Code :

void displayTree (Tree *tree)
{
if (tree == NULL)
{
printf("The tree is empty\n" );
}
else
{
displayChildren (tree->first, 0); // Niveau 0
}
}
void displayChildren (Leaf *leaf, int depth)
{
int i;
for (i=0; i<depth; i++)
{
printf("\t" ); // Pour indenter l'affichage
leaf = leaf->child; // On récupère le fils suivant le niveau de profondeur auquel on est arrivé
}
displayFile (*(leaf->file));
while (leaf->next != NULL) // Tant qu'on a un suivant
{
displayChildren (leaf->next, depth+1);
leaf = leaf->next;
}
}

Bien entendu, ça ne m'affiche pas tout, et je vois pourquoi :
- 1er appel à displayChildren avec le premier noeud, il l'affiche. Ensuite il fait appel au next (des fois qu'il y en aurait), et comme il n'y en a pas, il s'arrête. Or mon premier noeud à des fils, et ces derniers sont ignorés ...

Je suis mal parti ?

Message édité par Ydalb le 03-11-2010 à 01:11:06

---------------
:o

olivthill

Je n'ai pas regardé dans le détail, je laisse cela aux bon spécialistes du C de ce forum.

Juste quelques remarques sur la nomenclature :

Code :

typedef struct Tree
{
Leaf *first;
} Tree;

Il ne faut pas nommer de la même manière la structure (le premier Tree) et l'espace alloué pour la structure (le dernier Tree). Une convention assez répandue est de nommer la structure en la faisant commencer par un tiret de soulignement, ce qui donnerait :

Code :

typedef struct _Tree
{
Leaf *first;
} Tree;

En plus, il y a une confusion à cause du typedef.
Pour infos, le typedef n'est pas obligatoire, mais les profs l'aiment beaucoup. Quand on l'utilise, une convention assez répandue est de donner un nom tout en majuscules.
Si on utilise un typedef, alors, il dvient inutile de répeter le mot struct. Gagner ces 6 lettres est un avantage (pour certains (personnellement, je n'utilise japmais typedef car je trouve que cela rend le code moins lisible en cachant ce mot struct, mais c'est un débat de trolls)).

Citation :

Leaf *leaf ... File *file;

Il vaut mieux éviter d'avoir des noms qui se ressemblent trop, car on a vite fait d'oublier la majuscule ou la minuscule.

Message édité par olivthill le 03-11-2010 à 09:41:59

Ydalb

In Crêpes n' Cidre I Trust!

Merci pour tes remarques, mais j'ai toujours eu l'habitude (grâce / à cause des profs ) d'utiliser typedef.

pour les noms de variables, je me sers de la règles : commence par une majuscule, c'est un type, commence par une minuscule, c'est une variable, et ça se passe bien.

Reste plus qu'à voir pour le parcours de l'arbre

---------------
:o

breizhbugs

Je verrais plutot ton fonction displayChildren comme ca (non testée!):

Code :

void displayChildren (Leaf *leaf, int depth)
{
int i;
if (leaf != NULL)
{
for (i=0; i<depth ; i++)
{
printf("\t" ); // Pour indenter l'affichage
}
displayChildren(Leaf->child, depth+1); // on affiche d'abord les fils (donc a une profondeur de plus)
displayChildren (leaf->next, depth); // Les nœuds "frères" sont au même niveau!, on n'affiche que le premier (qui lui affichera a son tour son premier, etc)
displayFile (*(leaf->file)); // on affiche les fichiers du répertoire courant.
}
}

Message édité par breizhbugs le 03-11-2010 à 14:47:45

theshockwave

I work at a firm named Koslow

pour faire ce genre de traitements, j'aurais intuitivement envie d'éviter de stocker des infos sur chaque fichier en mémoire vu que le nombre de fichiers à traiter va probablement être conséquent.

Je te conseillerais plutôt de partir plus dans une optique de requête et appliquer cette requête sur chaque fichier / dossier en faisant une passe sur ton disque.

La requête sachant elle-même si elle doit compter des fichiers, calculer une taille ou autre. Ca a un autre avantage, c'est que tu pourras faire des requêtes composites assez aisément avec un système de ce genre.

---------------
last.fm

FORUM HardWare.fr

Programmation

[C] Structure de données à utiliser pour le parcours de dossier

Sujets relatifs
Transfert de données DB2/400 vers Oracle	[C] Récuper l'utilisateur à partir de l'uid
Importer données d'un autre site sur son site web	Structure en c sur un tableau de chaine de caractere
[C#] Erreur lors de l'ouverture d'un fichier	langage C, message d'erreur
Ouvrir fenêtre Glut depuis fenêtre C#	[C] tableau dynamique 2 dimension
Comparaison/Test de "structure" XML	[Apprentissage] Passage de Java à C#
Plus de sujets relatifs à : [C] Structure de données à utiliser pour le parcours de dossier

Page générée en 0.068 secondes