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



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é.