Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1811 connectés 

 
 


 Mot :   Pseudo :  
 
 Page :   1  2
Page Suivante
Page Précédente
Bas de page 
Auteur Sujet :

a propos de char **

n°1234971
Emmanuel D​elahaye
C is a sharp tool
Posté le 31-10-2005 à 13:45:54  profilanswer
 

Reprise du message précédent :

super-tupapau a écrit :

j'ai compris!
 
quand je même ceci:

Code :
  1. typedef struct arch * diskc_arch;
  2. diskc_arch **list = NULL;


 
ca donne un pointeur sur un pointeur sur un pointeur.
j'ai donc supprimer mit

Code :
  1. typedef struct arch diskc_arch;


comme ca j'ai plus d'erreur de compilation ms un segment fault avec list[i]->name = strdup( entry->d_name );


Ben oui. Tu as alloué le tableau mais pas les éléments...

Citation :


et pour le free je ferais comme ca?

Code :
  1. if (file != NULL)
  2.     for( i = 0; i<nb_file-1; i++ )
  3. free(file->next+i);
  4.     free(file);




Insuffisant. Chaque strdup() doit être compensé par un free(). C'est dans la doc, tu ne l'as donc pas lue malgré mon insistance ? Mais qu'est-ce qu'il faut faire pour se faire entendre ?


---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
mood
Publicité
Posté le 31-10-2005 à 13:45:54  profilanswer
 

n°1235006
super-tupa​pau
Posté le 31-10-2005 à 14:26:41  profilanswer
 

j'ai lu la doc et je sais qui faut mettre ces free(); reste encore a réussir a les mettre  :heink: .
 

Code :
  1. if (file != NULL){
  2.     for( i = 0; i<nb_file-2; i++ )
  3. free((file->next+i)->name);
  4. free((file->next+i)->chemin);
  5. free(file->next+i);
  7.     free(file->name);
  8.     free(file->chemin);
  9.     free(file);
  10.     }


 

n°1235015
super-tupa​pau
Posté le 31-10-2005 à 14:30:18  profilanswer
 

Pour les éléments du tableau list j'ai fait comme ceci:

Code :
  1. list[i] = malloc( sizeof(diskc_arch) );

n°1235025
super-tupa​pau
Posté le 31-10-2005 à 14:34:22  profilanswer
 

ca donne ceci:

Code :
  1. /* DISKCLEAN --[ Trieur/Nettoyeur de dossier personnel ]-- */
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <dirent.h>
  6. #include <string.h>
  8. /* DISKCLEAN  
  9.    STRUCTURE --[ diskc_arch ]--
  10.    Structure chainée
  11. */
  13. struct arch {
  15. char *name;
  16. char *chemin;
  17. struct arch *next;
  18. struct arch *subdir;
  20. };
  22. typedef struct arch diskc_arch;
  25. /* DISKCLEAN  
  26.    FONCTION --[ diskc_readir ]--
  27.    Lecteur de dossier récursif.
  28.    Retourne un pointeur sur  
  29.    tableau des fichiers présent  
  30.    dans le dossier spécifié
  31.    en argument.
  32. */
  34. /* Nombre de fichier analysé */
  35. int nb_file = 1;
  37. diskc_arch * diskc_readir(const char *directory)
  38. {
  40.     DIR *dir = NULL;
  41.     struct dirent *entry = NULL;
  42.     diskc_arch **list = NULL;
  43.     int i=0;
  45. /* Ouverture du répertoire */
  46.     dir = opendir(directory);
  47.     if (dir == NULL)
  48. return NULL;
  50. /* Lecture du dossier */
  51.     while ((entry = readdir(dir)) != NULL) {
  53. if (strcmp(entry->d_name, "." ) != 0
  54.     && strcmp(entry->d_name, ".." ) != 0) {
  55.     list = realloc( list, nb_file * sizeof *list );
  56.    
  57.    if( list == NULL )
  58.  printf("list est null\n" );
  59.  return NULL;
  61.     /* Compléter les informations du fichiers: nom, chemin, pointeur suivant, pointeur précédent */
  62.     list[i] = malloc( sizeof(diskc_arch) );
  63.     list[i]->name = strdup( entry->d_name );
  64.             list[i]->chemin = strdup( directory );
  65.             list[i]->next = list[i+1];
  66.     list[i]->subdir = NULL;
  68.             nb_file++;
  69. i++;
  70. }
  72.     }
  74.     closedir(dir);
  76.     return list[0];
  77. }
  80. /* DISKCLEAN  
  81.    FONCTION --[ main ]--
  82.    Appeler par le systeme
  83.    Aucun arguments
  84. */
  85. int main( int argc, char ** argv )
  86. {
  87.     int i;
  88.     diskc_arch *file = NULL;
  90.     if(argv[1] == NULL)
  91. return EXIT_FAILURE;
  93.     file = diskc_readir(argv[1]);
  94.     if (file == NULL)
  95. printf("file est null\n" );
  96. return EXIT_FAILURE;
  99.     printf("file+0: %s\n", file->name);
  102.     if (file != NULL){
  103.     for( i = 0; i<nb_file-2; i++ )
  104. free((file->next+i)->name);
  105. free((file->next+i)->chemin);
  106. free(file->next+i);
  108.     free(file->name);
  109.     free(file->chemin);
  110.     free(file);
  111.     }
  113.     return EXIT_SUCCESS;
  114. }


 
et j'obtient à l'execution:
file est null.

Message cité 1 fois
n°1235054
super-tupa​pau
Posté le 31-10-2005 à 15:15:20  profilanswer
 

Mes free donner n'importe koi. j'ai un probléme avec le next de la structure arch. je voudrais stocker dedans l'adresse de l'élément suivant en le decalant de un ms je crois que c impossible en fait car le realloc a surment changer complément espace mémoire utiliser entre deux appel.

n°1235065
super-tupa​pau
Posté le 31-10-2005 à 15:21:25  profilanswer
 

voila la correction:
 

Code :
  1. /* DISKCLEAN --[ Trieur/Nettoyeur de dossier personnel ]-- */
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <dirent.h>
  6. #include <string.h>
  8. /* DISKCLEAN  
  9.    STRUCTURE --[ diskc_arch ]--
  10.    Structure chainée
  11. */
  13. struct arch {
  15.     char *name;
  16.     char *chemin;
  17.     struct arch *subdir;
  19. };
  21. typedef struct arch diskc_arch;
  24. /* DISKCLEAN  
  25.    FONCTION --[ diskc_readir ]--
  26.    Lecteur de dossier récursif.
  27.    Retourne un pointeur sur  
  28.    tableau des fichiers présent  
  29.    dans le dossier spécifié
  30.    en argument.
  31. */
  33. /* Nombre de fichier analysé */
  34. int nb_file = 1;
  36. diskc_arch **diskc_readir(const char *directory)
  37. {
  39.     DIR *dir = NULL;
  40.     struct dirent *entry = NULL;
  41.     diskc_arch **list = NULL;
  42.     int i = 0;
  44. /* Ouverture du répertoire */
  45.     dir = opendir(directory);
  46.     if (dir == NULL)
  47. return NULL;
  49. /* Lecture du dossier */
  50.     while ((entry = readdir(dir)) != NULL) {
  52. if (strcmp(entry->d_name, "." ) != 0
  53.     && strcmp(entry->d_name, ".." ) != 0) {
  54.     list = realloc(list, nb_file * sizeof *list);
  56.     if (list == NULL)
  57.  return NULL;
  59.     /* Compléter les informations du fichiers: nom, chemin, pointeur suivant, pointeur précédent */
  60.     list[i] = malloc(sizeof(diskc_arch));
  61.     list[i]->name = strdup(entry->d_name);
  62.     list[i]->chemin = strdup(directory);
  63.     list[i]->subdir = NULL;
  65.     nb_file++;
  66.     i++;
  67. }
  69.     }
  71.     closedir(dir);
  73.     return list;
  74. }
  77. /* DISKCLEAN  
  78.    FONCTION --[ main ]--
  79.    Appeler par le systeme
  80.    Aucun arguments
  81. */
  82. int main(int argc, char **argv)
  83. {
  84.     int i;
  85.     diskc_arch **file = NULL;
  87.     if (argv[1] == NULL)
  88. return EXIT_FAILURE;
  90.     file = diskc_readir(argv[1]);
  91.     if (file == NULL)
  92. return EXIT_FAILURE;
  94.     for (i = 0; i < nb_file - 1; i++) {
  95. printf("%s%s\n", file[i]->chemin, file[i]->name);
  96.     }
  99.     free(file);
  100.     for (i = 0; i < nb_file - 1; i++) {
  101. free(file[i]->name);
  102. free(file[i]->chemin);
  103.     }
  105.     return EXIT_SUCCESS;
  106. }

n°1235070
Emmanuel D​elahaye
C is a sharp tool
Posté le 31-10-2005 à 15:27:50  profilanswer
 

super-tupapau a écrit :

ca donne ceci:
<...>
et j'obtiens à l'execution:
file est null.


 
Ca me parait bien tordu. Dans un premier temps, s'assurer qu'on sait lire un répertoire et stocker les informations qui vont bien :  


/* DISKCLEAN --[ Trieur/Nettoyeur de dossier personnel ]-- */
 
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <string.h>
 
/* DISKCLEAN
   STRUCTURE --[ diskc_arch ]--
*/
 
struct arch
{
    char *name;
    char *chemin;
};
 
typedef struct arch diskc_arch;
 
/* DISKCLEAN
   FONCTION --[ diskc_readir ]--
   Lecteur de dossier récursif.
   Retourne un pointeur sur  
   tableau des fichiers présent  
   dans le dossier spécifié
   en argument.
*/
 
/* -ed-
diskc_arch * diskc_readir(const char *directory)
 
maintenant, il manque une '*'...  
*/
diskc_arch ** diskc_readir(const char *directory, int *p_nb_file)
{
    /* tableau des entrees  */
    diskc_arch **list = NULL;
     
    /* Nombre de fichiers analyses */
    int nb_file = 0;
     
    /* Ouverture du répertoire */
    DIR *dir = opendir(directory);
     
    if (dir != NULL)
    {
        struct dirent *entry = NULL;
        int i=0;
         
        /* Lecture du dossier */
        while ((entry = readdir(dir)) != NULL)
        {
            if (strcmp(entry->d_name, "." ) != 0
                    && strcmp(entry->d_name, ".." ) != 0)
            {
                nb_file++;
                 
                {
                    /* -ed- realloc() a quelques precautions d'usage... */
                    void *tmp = realloc( list, nb_file * sizeof *list );
                     
                    if( tmp != NULL )
                    {
                        list = tmp;
                         
                        /* creer un element */
                        list[i] = malloc (sizeof *list[i]);
                         
                        if (list[i] != NULL)
                        {
                            /* Compléter les informations du fichiers: nom, chemin, pointeur suivant, pointeur précédent */
                            list[i]->name = strdup (entry->d_name );
                            list[i]->chemin = strdup( directory );
                             
                            i++;
                        }
                        else
                        {
                            printf ("memory error (list[%d])\n", i);
                            break;
                        }
                    }
                    else
                    {
                        printf ("memory error (list)\n" );
                        break;
                    }
                }
            }
        }
         
        closedir(dir);
    }
     
    if (p_nb_file != NULL)
    {
        *p_nb_file=nb_file;
    }
    /* -ed-
        return list[0];
     
    mise au point  
    */
    return list;
}
 
 
/* DISKCLEAN
   FONCTION --[ main ]--
   Appeler par le systeme
   Aucun arguments
*/
int main( int argc, char ** argv )
{
    int ret;
     
    /* -ed-
    diskc_arch *file = NULL;
     
    mise au point  
    */
    diskc_arch **file = NULL;
     
    if(argc > 1)
    {
     
        /* Nombre de fichier analysé */
        int nb_file;
         
        file = diskc_readir(argv[1], &nb_file);
        if (file == NULL)
        {
            printf("file est null\n" );
            return EXIT_FAILURE;
        }
        else
        {
            /* -ed-
            Quelle salade. Il faut defaire les choses dans l'ordre inverse...  
             
                    for( i = 0; i<nb_file-2; i++ )
                        free((file->next+i)->name);
                    free((file->next+i)->chemin);
                    free(file->next+i);
                     
                    free(file->name);
                    free(file->chemin);
                    free(file);
            */
            int i;
            for( i = 0; i<nb_file; i++ )
            {
                printf("file[%d]: %s\n", i, file[i]->name);
                 
                free(file[i]->name);
                free(file[i]->chemin);
                free(file[i]);
                 
                /* -ed-
                   mais si il faut parcourir l'arbre, c'est sans doute  
                   insuffisant. Il faut alors utiliser la recursion, c'est le  
                   plus simple a coder, mais pas le plus simple a aprehender.
                */
            }
        }
         
        ret = EXIT_SUCCESS;
    }
    else
    {
        ret = EXIT_FAILURE;
    }
    return ret;
}


Message édité par Emmanuel Delahaye le 31-10-2005 à 15:29:34

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
n°1236015
super-tupa​pau
Posté le 01-11-2005 à 23:08:23  profilanswer
 

Voila j'ai ajouter tous les tests sur les pointeurs et les mallocs (dite le moi si j'en ai oublié) et j'ai aussi mit en place la récursivité:
 

Code :
  1. /* DISKCLEAN --[ Trieur/Nettoyeur de dossier personnel ]-- */
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <dirent.h>
  6. #include <string.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <unistd.h>
  13. /* DISKCLEAN  
  14.    STRUCTURE --[ diskc_arch ]--
  15.    Structure chainée
  16. */
  18. struct arch
  19. {
  21.   char *name;
  22.   char *chemin;
  23.   char *type;
  24.   int level;
  26. };
  28. typedef struct arch diskc_arch;
  31. /* DISKCLEAN  
  32.    FONCTION --[ diskc_readir ]--
  33.    Lecteur de dossier récursif.
  34.    Retourne un pointeur sur  
  35.    tableau des fichiers présent  
  36.    dans le dossier spécifié
  37.    en argument.
  38. */
  40. diskc_arch **
  41. diskc_readir (const char *directory, int *nb_file, diskc_arch ** last_list,
  42.    int level, int *pos)
  43. {
  44. /* Tableau des fichiers analysées */
  45.   diskc_arch **list = NULL;
  47. /* Nombre de fichier analysée */
  48.   int nb = 0;
  50. /* Niveau d'analyse */
  51.   int this_level = level;
  53.   if (last_list != NULL)
  54.     {
  55.       list = last_list;
  56.     }
  58. /* Structure stat */
  59.   struct stat info;
  61. /* Ouverture du répertoire */
  62.   DIR *dir = opendir (directory);
  63.   if (dir != NULL)
  64.     {
  66.       struct dirent *entry = NULL;
  67.       int i = *nb_file;
  69. /* Lecture du dossier */
  70.       while ((entry = readdir (dir)) != NULL)
  71. {
  73.   if (strcmp (entry->d_name, "." ) != 0
  74.       && strcmp (entry->d_name, ".." ) != 0)
  75.     {
  76.       nb++;
  78.       void *tmp = realloc (list, (nb + *nb_file) * sizeof *list);
  79.       if (tmp != NULL)
  80.  {
  81.    list = tmp;
  83.    list[i] = malloc (sizeof (diskc_arch));
  84.    if (list[i] != NULL)
  85.      {
  87.        /* Compléter les informations du fichiers: nom, chemin, pointeur suivant, pointeur précédent */
  88.        list[i]->name = strdup (entry->d_name);
  89.        list[i]->chemin = strdup (directory);
  91.        /* Chemin du fichier */
  92.        char *chemin = NULL;
  93.        chemin = strdup (directory);
  94.        chemin =
  95.   realloc (chemin,
  96.     strlen (chemin) + 1 +
  97.     sizeof (entry->d_name));
  99.        if (chemin != NULL)
  100.   {
  101.     strcat (chemin, entry->d_name);
  103.     if ((stat (chemin, &info)) >= 0)
  104.       {
  106.         if (S_ISDIR (info.st_mode))
  107.    {
  108.      list[i]->type = "Dossier";
  109.    }
  111.         else
  112.    {
  113.      list[i]->type = "Fichier";
  114.    }
  115.         list[i]->level = this_level;
  117.       }
  119.     else
  120.       {
  121.         printf
  122.    ("impossible de récupérer les information de %s\n",
  123.     chemin);
  124.         return NULL;
  125.       }
  126.     free (chemin);
  127.   }
  128.        else
  129.   {
  130.     printf ("impossible d'allouer (chemin)\n" );
  131.     return NULL;
  132.   }
  133.        i++;
  134.      }
  135.    else
  136.      {
  137.        printf ("impossible d'allouer (list[%i])\n", i);
  138.        return NULL;
  139.      }
  141.  }
  142.       else
  143.  {
  144.    printf ("impossible d'allouer (list)\n" );
  145.    return NULL;
  146.  }
  147.     }
  149. }
  151.       closedir (dir);
  153.       if (nb_file != NULL)
  154. {
  155.   *nb_file = *nb_file + nb;
  156. }
  158. /* Récursivité */
  159.       if( pos != NULL ){
  161.       int j = *pos;
  162.       while (j < *nb_file)
  163. {
  165.   if (list[j]->type == "Dossier" && list[j]->level == this_level)
  166.     {
  167. /* Chemin du fichier */
  168.       char *chemin = NULL;
  169.       chemin = strdup (directory);
  170.       chemin = realloc (chemin, sizeof (*chemin) + NAME_MAX+1 + 1); /* on ajoute 1 pour le / */
  172.       if (chemin != NULL)
  173.  {
  174.    strcat (chemin, list[j]->name);
  175.    strcat (chemin, "/" );
  176.    list =  diskc_readir (chemin, nb_file, list, this_level+1, pos);
  177.    free (chemin);
  178.  }
  180.       else
  181.  {
  182.    printf ("impossible d'allouer (chemin)" );
  183.    return NULL;
  184.  }
  186.     }
  188.   j++;
  190. }
  191.    
  192.     *pos = j;
  193.     }
  195.     else{
  196.  printf("impossible de récupérer la position dans le dossier" );
  197. return NULL;
  198.     }
  199.     }
  201.   else
  202.     {
  203.       printf ("impossible d'ouvrir le répertoire: %s\nVérifiez si vous avez les droits d'accès sur ce dossier.\n", directory);
  204.     }
  206.   return list;
  207. }
  210. /* DISKCLEAN  
  211.    FONCTION --[ main ]--
  212.    Appeler par le systeme
  213.    Aucun arguments
  214. */
  215. int
  216. main (int argc, char **argv)
  217. {
  218.   int i;
  219.   diskc_arch **file = NULL;
  221.   /* Nombre de fichier analysé */
  222.   int nb_file = 0;
  223.   int pos = 0;
  225.   if (argv[1] != NULL)
  226.     {
  229.       file = diskc_readir (argv[1], &nb_file, NULL, 0, &pos);
  230.       if (file != NULL)
  231. {
  232.   for (i = 0; i < nb_file; i++)
  233.     {
  234.       printf ("[%s N°%i][LEVEL]:%i:%s%s\n", file[i]->type, i, file[i]->level, file[i]->chemin,
  235.        file[i]->name);
  236.     }
  239.   for (i = 0; i < nb_file; i++)
  240.     {
  241.       free (file[i]->name);
  242.       free (file[i]->chemin);
  243.       free (file[i]);
  244.     }
  245. }
  246.       else
  247. {
  248.   return EXIT_FAILURE;
  249. }
  251.     }
  252.   else
  253.     {
  254.       return EXIT_FAILURE;
  255.     }
  257.   return EXIT_SUCCESS;
  258. }


 
note: le programme est tres lent sur de tres gros dossier ( logic ) or il serait preferable qu'il soit plus rapide vu qu'il a pour objectif de rechercher les fichiers en double. enfin il a planter sur mon dossier home apres une 20 de seconde:
 
la glib me signalant un double free. il y a un test faux ds mon programme?


Message édité par super-tupapau le 01-11-2005 à 23:16:31
n°1236031
super-tupa​pau
Posté le 01-11-2005 à 23:20:58  profilanswer
 

j'ai resolu le problème lenteur en ignorant les dossier commencant par un '.' car ces dossiers ne sont pas directement modifier pas l'utilisateur il ont donc pas besoin d'être vérifiés.

mood
Publicité
Posté le   profilanswer
 

 Page :   1  2
Page Suivante
Page Précédente
Haut de page 

Aller à :
Ajouter une réponse
 

Sujets relatifs
à propos de cadres.. ou recherche d'une autre solutionaide à propos strstr
Fonction qui modifie un char *a propos des combobox
[HTML] question toute bete à propos des tableaux Question a propos de Visual C++ 2005
[batch] longueur d'une chaine de charConvertir un char en int ?!
PB: Fonction de conversion Unicode->charerror: invalid operands of types 'const char [15]' and 'short ..
Plus de sujets relatifs à : a propos de char **

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.122 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR