Ls recursif en C
bibiloute
-
bibiloute -
bibiloute -
slt! voila j'ai un petit probleme (vous vous en seriez doute!) j'essaie de faire un ls recursif( la celebre commande ls -R sous linux), j'ai reussi a faire le ls de base(sans recursivite) mais tout ce complique qd j'essaie le recursif!
help me!!!!!!
#include<stdio.h>
#include<dirent.h>
#include<sys/types.h>
#include<stdlib.h>
#include<string.h>
int regFlag=0; //drapeau pour l'option -R
//fonction non utilise pour l'instant , le test d'option est fait directement ds le main
//char *parseArgs(int argc,char **argv){
//if ((argv[1][0]=='-')&&(argv[1][1]=='R')) regFlag=1;
//else {if (argc>=2) printf("mauvaise option");}
//return (argv[2]);
//}
//fonction qui concatene src et dest avec allocation de memoire
char *extendString(char *dest,const char *src){
if (!(dest=(char*)realloc(dest,(strlen(dest)+strlen(src)+1)*sizeof(char))))
{
puts("impossible d'allouer");
exit;
}
strcat(dest,src);
return(dest);
}
//fonction du ls recursif
int stdlistdir(const char* nameDir){
DIR *dir_stream;
char* entree;
struct dirent *dir_ent;
dir_stream=opendir(nameDir);
if (dir_stream==NULL){
printf("erreur de lecture");
exit;
}
while(1){
dir_ent=readdir(dir_stream);
if (regFlag==1){ //si l'option est activee...
entree=(char *)strdup(nameDir);
extendString(entree,"/");
extendString(entree,dir_ent->d_name);
strcat(entree,nameDir);
if (*dir_ent->d_name!='.')
printf("%s\n",dir_ent->d_name);
}
else if (*(dir_ent->d_name)!='.') //sinon
printf("%s\n",dir_ent->d_name);
}
closedir(dir_stream);
}
int main(int argc,char* argv[]){
//test si l'option est presente
if ((argv[1][0]=='-')&&(argv[1][1]=='R')) {
regFlag=1;
stdlistdir(argv[2]);
}
else stdlistdir(argv[1]);
getchar();
}
merci d'avance o toi grand sage de l'info lol
help me!!!!!!
#include<stdio.h>
#include<dirent.h>
#include<sys/types.h>
#include<stdlib.h>
#include<string.h>
int regFlag=0; //drapeau pour l'option -R
//fonction non utilise pour l'instant , le test d'option est fait directement ds le main
//char *parseArgs(int argc,char **argv){
//if ((argv[1][0]=='-')&&(argv[1][1]=='R')) regFlag=1;
//else {if (argc>=2) printf("mauvaise option");}
//return (argv[2]);
//}
//fonction qui concatene src et dest avec allocation de memoire
char *extendString(char *dest,const char *src){
if (!(dest=(char*)realloc(dest,(strlen(dest)+strlen(src)+1)*sizeof(char))))
{
puts("impossible d'allouer");
exit;
}
strcat(dest,src);
return(dest);
}
//fonction du ls recursif
int stdlistdir(const char* nameDir){
DIR *dir_stream;
char* entree;
struct dirent *dir_ent;
dir_stream=opendir(nameDir);
if (dir_stream==NULL){
printf("erreur de lecture");
exit;
}
while(1){
dir_ent=readdir(dir_stream);
if (regFlag==1){ //si l'option est activee...
entree=(char *)strdup(nameDir);
extendString(entree,"/");
extendString(entree,dir_ent->d_name);
strcat(entree,nameDir);
if (*dir_ent->d_name!='.')
printf("%s\n",dir_ent->d_name);
}
else if (*(dir_ent->d_name)!='.') //sinon
printf("%s\n",dir_ent->d_name);
}
closedir(dir_stream);
}
int main(int argc,char* argv[]){
//test si l'option est presente
if ((argv[1][0]=='-')&&(argv[1][1]=='R')) {
regFlag=1;
stdlistdir(argv[2]);
}
else stdlistdir(argv[1]);
getchar();
}
merci d'avance o toi grand sage de l'info lol
5 réponses
Je donne ma langue au chat :-P . En tout cas il est pas beau ton code, pas assez aéré, les blocs ne sont pas clairement reconnaissables bref faudrait apprendre à faire de la mise en forme de code pour que ce soit le plus maintenable possible.
je n et'ecrirais pas le code, car je n'ai pas le temps, et puis ce que j'vais fait etait plus court que ce que t'as fait, mais je ne sais plus ou je l'ai mis, voici le principe :
void lsr (char *dir) {
[tab] ouvrir dir et ts les tests qui s'en suivent;
[tab] while ((entree = readdir(dir))!=null) {
[tab] if( isdir(entree)) lsr ( entree);
[tab] else printf (entree);
[tab]}
}
voilou un pseudo code, mi-C mi-Français.
Le principe du recursif c'est de s'appeler soi-meme et de s'arreter avec une condition d'arret. Or ds ta fct je ne vois aucun appel a lui-meme.
J'espere t'avoir aide.
tafiscobar
void lsr (char *dir) {
[tab] ouvrir dir et ts les tests qui s'en suivent;
[tab] while ((entree = readdir(dir))!=null) {
[tab] if( isdir(entree)) lsr ( entree);
[tab] else printf (entree);
[tab]}
}
voilou un pseudo code, mi-C mi-Français.
Le principe du recursif c'est de s'appeler soi-meme et de s'arreter avec une condition d'arret. Or ds ta fct je ne vois aucun appel a lui-meme.
J'espere t'avoir aide.
tafiscobar
comme son nom l'indique, il te retourne vrai si l'entree donne en argument est un repertoire ou non, je ne me rappelle pas qu'elle existe, en fait il doit y avoir ds les champs de la structure DIR, un champ type qui specifie si c'est un lien, ou un fichier simple ou un repertoire, etc... je pense qu'il s'appelle DT_DIR. En fait le test if(isdir(entree)) c'est eqyuivalent a ca:
if(entree->d_type == DT_DIR) lsr(strcpy(malloc(strlen(entree->dir)*sizeof(char)),entree->d_name));
tafiscobar
if(entree->d_type == DT_DIR) lsr(strcpy(malloc(strlen(entree->dir)*sizeof(char)),entree->d_name));
tafiscobar
salut,
En gros, ça devrait marcher, j'ai ressorti un vieux tp :)
@++
Vous hésitez entre Linux et Windows ?
Vous voulez dépenser du temps ou de l'argent ?
void disp_dir(char* dirpath)//, int rec, char onebylinemode, char longformat)
{ DIR* dirtolist = NULL;
struct dirent* d_filename = NULL;
if ( dirpath==NULL)
{
fprintf(stderr, "Erreur : nom de répertoire passe NULL\n");
exit(1);
}
if( opendir(dirpath)==NULL )
{
return ;
}
// ici, on sait qu'on a affaire à un répertoire, donc on le parcourt
//récursivement
if ( (dirtolist = opendir(dirpath)) == NULL )
{
perror("opendir ");
exit(1);
}
while ( (d_filename = readdir(dirtolist)) != NULL )
{
/* affichage inconditionnel du nom de fichier ou de repertoire
*/
printf(" %s", d_filename->d_name);
printf("\t");
/* si on est en mode récursif et qu'on a un rep, on enregistre
son nom pour le traiter ensuite */
if( opendir(d_filename->d_name)!=NULL &&
strcmp(d_filename->d_name,".")!=0 &&
strcmp(d_filename->d_name,"..")!=0)
{
disp_dir( d_filename->d_name);
}
}
}
En gros, ça devrait marcher, j'ai ressorti un vieux tp :)
@++
Vous hésitez entre Linux et Windows ?
Vous voulez dépenser du temps ou de l'argent ?
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
type ma_fonction(type argument) {
/* instructions */
}
une fonction toute simple pour identifier le bloc (début/fin) c'est déjà un peu la galère du à la lecture verticale d'instructions alors pour une imbrication voilà ce que ça donne:
type ma_fonction1(type argument) {
/* instructions */
type ma_fonction2(type argument) {
/* instructions */
type ma_fonction3(type argument) {
/* instructions */
}
}
}
je préfère de loin un style de ce genre qui me permet de mieux m'y retrouver:
type ma_fonction1(type argument)
{
/* instructions */
type ma_fonction2(type argument)
{
/* instructions */
type ma_fonction3(type argument)
{
/* instructions */
}
}
}
A savoir aussi faire des tabulations utiles car décaler c'est bien mais donner un sens au décalage c'est encore mieux. J'utilise la tabulation pour signaler un élément ou instruction imbriqué dans un bloc.
Exemple:
...
{
[tab]/* instruction */
[tab]{
[tab][tab]/* instruction */
[tab]}
}
...
Avec cette méthode je suis quasi-certain de jamais me planter sur la fermeture d'un bloc car il suffit de lire à la verticale les accolades pour savoir si un bloc n'a pas été fermé.