Discussion :

[alexinho]

Salut,

J'ai créé une fonction récursive qui parcours une arborescence à la recherche d'un certain type de dossier, qui les Zippes quand elle les trouve. J'ai galéré toute l'après midi avec l'assignation de mémoire dynamique pour des tableaux de chaines. J'ai pourtant consulté beaucoup de pages de forums, et j'ai l'impression d'avoir fait ce qu'il fallait. Le code compile, mais l'appli crash au bout de quelques secondes. Je ne vous mets qu'un bout du code...
Y'a-t'il un pro qui aurait quelques minutes pour m'aider ?

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
 
int arbo (char PATH[256])
{
...
char **SubFolderNames = NULL;
 
struct dirent *folder;     //|Déclaration de la structure qui contiendra le dossier 
   DIR *rep;               //|
 
   rep = opendir(PATH);     //Ouvre les sous dossiers de rep  
 
 
   while ((folder = readdir(rep)))       //boucle qui traite tous les sous dossiers
   {
   if (i%STEP ==2) {SubFolderNames = realloc (SubFolderNames, (i + STEP) * sizeof (char *));}
   if (i>1)        //si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas)
      { 
       SubFolderNames[i]= (char *) malloc (sizeof (folder->d_name));         
       RESULTS[i]=0;     
       strcpy(SubFolderNames[i],folder->d_name);  //On recupère le nom du ième sous dossier dans SubFolderNames
       sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[i]);   //On stocke le chemin du sous dossier en cours dans FULLPATH       
 
       if (Project_Or_Not(FULLPATH) )    //Si le sous dossier est un projet 
          {    ....    }
       else           //Si le sous dossier n'est pas un projet
          {
         if (opendir(FULLPATH))                
             {
             RESULTS[i]=arbo(FULLPATH);  //appelle de la fontion 
             }           
         else   {   ...   }
          }
 
      } //fin de if (i>1) 
 
   i++; 
   }//Fin du while qui traite les sous dossiers 
...
}//Fin de la fonction arbo

Je suis bien sur a votre disposition si vous avez besoin d'éclaircissements ou de voir plus de code.
Merci d'avance

[granquet]

si les fonctions renvoient des choses, c'est une bonne idée de tester ce qu'elles renvoient.

http://emmanuel-delahaye.developpez....es.htm#realloc

[Franck.H]

Tu as mal alloué l'espace pour la chaîne, il faut faire ceci:

Code :

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

1
2
3
4
5
6
SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
 
if (SubFolderNames[i] != NULL)
{
   /* Remplissage de la chaine... */
}

D'ailleurs le cast sur le retour des allocations dynamique ne sont pas recommandé et même inutiles en C

[souviron34]

[
Plusieurs choses d'emblée :

Code :

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

1
2
   while ((folder = readdir(rep)) != NULL)       //boucle qui traite tous les sous dossiers

Code :

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

1
2
       SubFolderNames[i]= (char *) malloc (sizeof (folder->d_name)+1);

Et il faudrait tester le code de retour avant de faire le strcpy...

D'autre part es-tu sûr que PATH et FULLPATH soit inférieur à 256 ?

[Gruik]

Oui, on ne sait pas ce qu'est FULLPATH

[alexinho]

Merci pour vos remarques et suggestions qui m'ont presque toutes toutes servies.
J'ai même réussit a avoir un code stable pendant un moment en mélangeant des chaines de taille fixe et des chaînes de taille dynamique, mais je me suis dit que j'allais tout passer en dynamique pour le coté fonctionnel d'une part, et pour le coté pédagogique d'autre part.
Et me voilà donc encore en train d'appeler au secours
Cette fois-ci je vous mets l'integralité du code de la fonction, j'espère que ça fera pas trop usine a gaz pour vous...

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
int arbo (char *PATH)
//Cette fonction parcoureras l'arborescence à la recherche de projets et essaiera de zipper les projets qu'elle trouve
//Prends le chemin du dossier à analyser en paramètre, et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé 
{ 
 
int i=0;
int j;
int z=0;
int u=0;
 
char * CmdLine= malloc(sizeof(char));   
char * FULLPATH = malloc(sizeof(char));         //Contiendra le chemin complet du dossier en cours
int * RESULTS=NULL;     //contiendra une valeur associée a un dossier (RESULTS[i] associé a SubFolderNames[i])                 
int State;       //Code d'état (zip+rd)
 
char **SubFolderNames = NULL;  //Contient tous les sous dossiers du dossier en cours 
char **FoldersNotZipped = NULL;  //Contient les sous dossiers dont la valeur associée est 0
 
struct dirent * folder;     //|Déclaration de la structure qui contiendra le dossier en cours
   DIR *rep;                
   rep = opendir(PATH);     //Ouvre les sous dossiers de rep  
 
while ((folder = readdir(rep)))       //boucle qui traite tous les sous dossiers
   {
   if (i%STEP ==2) {SubFolderNames = realloc (SubFolderNames, (i + STEP) * sizeof (char *));} //Assignation mémoire SubFolderNames
   if (i>1)        //si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas)
      { 
       RESULTS=realloc(RESULTS, (i+1) * sizeof(int));    //assignation memoire RESULT
       SubFolderNames[i] = malloc (strlen (folder->d_name) + 1); //Assignation mémoire SubFolderNames[i]
 
       if (strlen(FULLPATH) < (strlen(SubFolderNames[i])+strlen(PATH)+1))  //|Assignation de mémoire 
          {                                                                //|pour FULLPATH si plus grand que 
          FULLPATH= realloc (FULLPATH,(strlen(SubFolderNames[i])+ strlen(PATH)+1)*sizeof(char));
          }
      if (SubFolderNames[i] != NULL)                                        
         {
         strcpy(SubFolderNames[i],folder->d_name);  //On recupère le nom du ième sous dossier dans SubFolderNames
         }  
       else {printf("\nNo more memory available\n"); system("pause"); }     
       RESULTS[i]=0;    
       sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[i]);   //On stocke le chemin du sous dossier en cours dans FullPATH       
       if (Project_Or_Not(FULLPATH) || !strcmp(SubFolderNames[i],"_Common"))    //Si le sous dossier est un projet ou un dossier Common
          {
          State=Add_Folder (FULLPATH);          //On le zippe
 
          if (State!=0) {fprintf(Log,"%s\n",FULLPATH);State=0;} //si erreur pendant la compression -> log
          else {
               CmdLine = realloc (CmdLine, (strlen(FULLPATH)+20)* sizeof(char));     //memoire pour CmdLine
               if (CmdLine!=NULL)
                  {
                  sprintf(CmdLine,"rd /S /Q \"%s\"",FULLPATH);State=system(CmdLine);//suppression du dossier 
                  }
               else {printf("\nNo more memory available\n"); system("pause"); }
               }     
          if (State!=0) {fprintf(Log,"%s\n",FULLPATH);}      //Si erreur pendant la supression ->log
 
          RESULTS[i]=1;        
          }
       else
          {
         if (opendir(FULLPATH))                
             {
             RESULTS[i]=arbo(FULLPATH); //appelle la fonction sur les sous dossiers
             }           
          else
             {
             RESULTS[i]=0;  
             }
          }
      } //fin de if (i>1) 
   i++; 
   }//Fin de la boucle qui traite les sous dossiers 
if (i==1) return 0;//Si le dossier est vide on renvoie 0
 
//Cette boucle compte les 0 et les 1 renvoyés par l'appel de la fonction sur les sous dossier du dossier en cours
for (j=2;j<i;j++)
    {
    if (j%STEP ==2) {FoldersNotZipped = realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));}
    if (RESULTS[j]==0) 
       {
       sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[j]);   //|On stocke le chemin du sous dossier en cours dans FullPATH  
       FoldersNotZipped[z]=  malloc ((strlen(FULLPATH)+1)* sizeof(char)); 
       if (FoldersNotZipped[z] != NULL)
        {//On stocke les chemins associé a un 0 dans le tableau FoldersNotZipped
         strcpy(FoldersNotZipped[z],FULLPATH); //On recupère le nom du ième sous dossier dans SubFolderNames
        }  
       else {printf("\nNo more memory available\n"); system("pause"); }         
       z++;
       }
    else 
       {
       u++;
       }
    }//fin de for (j=2;j<i;j++)
//Liberation des mémoires reservées
free (SubFolderNames);
free (RESULTS);
free (PATH);
//En fonction des valeurs renvoyées par les sous dossiers, on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier
if (u==0) {free(FoldersNotZipped); return 0; }
if (z==0) {free(FoldersNotZipped);return 1; }
if (u!=0 && z!=0)
     {      
      for (i=0;i<z;i++)
          {  
           if (opendir(FoldersNotZipped[i])) {fprintf(Log,"%s\n",FoldersNotZipped[i]);}
          ToCheck++;
          }     
      free(FoldersNotZipped);
      return 1;          
     }
 
}//fin de la fonction arbo

[Emmanuel Delahaye]

Cette fois-ci je vous mets l'integralité du code de la fonction, j'espère que ça fera pas trop usine a gaz pour vous...

La version compilable est payante ou quoi ?

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `arbo':
main.c:12: warning: implicit declaration of function `malloc'
main.c:14: error: `NULL' undeclared (first use in this function)
main.c:14: error: (Each undeclared identifier is reported only once
main.c:14: error: for each function it appears in.)
main.c:21: error: `DIR' undeclared (first use in this function)
main.c:21: error: `rep' undeclared (first use in this function)
main.c:22: warning: implicit declaration of function `opendir'
main.c:24: warning: implicit declaration of function `readdir'
main.c:24: warning: assignment makes pointer from integer without a cast
main.c:26: error: `STEP' undeclared (first use in this function)
main.c:26: warning: implicit declaration of function `realloc'
main.c:26: warning: assignment makes pointer from integer without a cast
main.c:29: warning: assignment makes pointer from integer without a cast
main.c:30: warning: implicit declaration of function `strlen'
main.c:30: error: dereferencing pointer to incomplete type
main.c:34: warning: assignment makes pointer from integer without a cast
main.c:38: warning: implicit declaration of function `strcpy'
main.c:38: error: dereferencing pointer to incomplete type
main.c:40: warning: implicit declaration of function `printf'
main.c:40: warning: implicit declaration of function `system'
main.c:42: warning: implicit declaration of function `sprintf'
main.c:43: warning: implicit declaration of function `Project_Or_Not'
main.c:43: warning: implicit declaration of function `strcmp'
main.c:45: warning: implicit declaration of function `Add_Folder'
main.c:47: warning: implicit declaration of function `fprintf'
main.c:47: error: `Log' undeclared (first use in this function)
main.c:49: warning: assignment makes pointer from integer without a cast
main.c:79: warning: assignment makes pointer from integer without a cast
main.c:97: warning: implicit declaration of function `free'
main.c:108: error: `ToCheck' undeclared (first use in this function)
Process terminated with status 1 (0 minutes, 3 seconds)
10 errors, 20 warnings

Faut arréter de nous faire perdre notre temps avec du code incomplet...

[alexinho]

Non bien sur, le reste du code est gratuit, comme l'amabilité du reste!
Loin de moi l'idée de faire perdre du temps a qui que ce soit, simplement il est écrit dans les règles du forum (et oui il y a des gens qui les lisent ) qu'il faut se limiter dans la quantité de code qu'on met sur le forum.
Mais puisque quelqu'un d'aussi experimenté que toi sembles assez sympa pour jetter un oeil sur mon travail d'amateur, je ne vais pas me priver :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <dirent.h>
#define STEP 15  
 
 
 
FILE * Log;                      //Declaration fichier log
int ToCheck=0;
int Length=0;
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
 
int Project_Or_Not (char *FULLPATH)
//Cette fonction determine si un dossier est un projet ou pas 
{
   struct dirent *lecture;     //|Déclaration de la structure qui contiendra le dossier en cours
   DIR *rep;                   //|
   char TEMP[256];           //Chaine temporaire
   rep = opendir(FULLPATH);     //Ouvre les sous dossiers de PATH   
   int sub=0;
 
    while ((lecture = readdir(rep)))         //|
    {                                        //|
    sprintf(TEMP,"%s",lecture->d_name);      //|On lit le nom de chaque sous dossier
    if (!strcmp(TEMP,"From_Cust")) sub++;    //|Si il a un des noms suivant, on incrémente 
    if (!strcmp(TEMP,"To_Cust")) sub++;      //|le compteur "sub".
    if (!strcmp(TEMP,"WORK")) sub++;         //|From_Cust, To_Cust, WORK, Admin
    if (!strcmp(TEMP,"Admin")) sub++;        //|sont des sous dossiers d'un projet
    }                                        //|
 
if (sub>=2) return 1;
return 0;
}
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
 
int Copy_wzzip (void)
//Cette fonction copie l'exe de winzip dans c:\windows\temp, afin de le lancer d'un chemin sans espace (pose des problèmes sinon)
{
    system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");    //crée une copie de winzip dans c:\windows\temp
}
 
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
 
int Add_Folder (char * FULLPATH)
//Cette fonction zippera un dossier dont le chemin 
{
  int Code;                                    //contiendra le code d'erreur
  int i;
  int j;
  char NAME[strlen(FULLPATH)];                              //Contiendra le nom du projet
  char SHORTPATH[strlen(FULLPATH)];                         //Contient le chemin sans le nom de projet
  char CmdLine[strlen(FULLPATH)+40];                           //Contiendra les Ligne de Commande passées au système
  strcpy(SHORTPATH,FULLPATH);
 
  for (i=(strlen(SHORTPATH)-1);i>=0;i--)       //Cette boucle parcours la chaine a l'envers    
      {
 
      if (SHORTPATH[i]=='\\')         //si on tombe sur un "\" on va remplace
         {
         for (j=i+1;j<=strlen(SHORTPATH);j++)      //Cette boucle extrait le nom de dossier          
             {
             NAME[j-(i+1)]=SHORTPATH[j];           //Copie caractère par caractère
             }
         SHORTPATH[i]='\0';
         i=-1;
         }                             
      } 
 
                                                                                               //|preparation de la ligne 
sprintf(CmdLine,"C:\\windows\\temp\\wzzip.exe -r -p -whs -en \"%s\\%s.zip\" \"%s\"",           //|de commande qui lance 
SHORTPATH,NAME,FULLPATH);                                                                      //|la Compression
 
 
  Code = system (CmdLine);    //on recupere le code d'état renvoyé par la ligne de commande
  //Ajouter la ligne qui efface le dossier
 
  free(SHORTPATH);    //|Liberation de l'espace memoire 
  free (CmdLine);     //|reservé pour les chaines
  free(NAME);         //| 
 
  return Code;        //retourne le code d'état
 
} 
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
 
int arbo (char *PATH)
//Cette fonction parcoureras l'arborescence à la recherche de projets et essaiera de zipper les projets qu'elle trouve
//Prends le chemin du dossier à analyser en paramètre, et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé 
{ 
 
int i=0;
int j;
int z=0;
int u=0;
 
char * CmdLine= malloc(sizeof(char));   
char * FULLPATH = malloc(sizeof(char));         //Contiendra le chemin complet du dossier en cours
int * RESULTS=NULL;     //contiendra une valeur associée a un dossier (RESULTS[i] associé a SubFolderNames[i])                 
int State;       //Code d'état (zip+rd)
 
char **SubFolderNames = NULL;  //Contient tous les sous dossiers du dossier en cours 
char **FoldersNotZipped = NULL;  //Contient les sous dossiers dont la valeur associée est 0
 
struct dirent * folder;     //|Déclaration de la structure qui contiendra le dossier en cours
   DIR *rep;                
   rep = opendir(PATH);     //Ouvre les sous dossiers de rep  
 
while ((folder = readdir(rep)))       //boucle qui traite tous les sous dossiers
   {
   if (i%STEP ==2) {SubFolderNames = realloc (SubFolderNames, (i + STEP) * sizeof (char *));} //Assignation mémoire SubFolderNames
   if (i>1)        //si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas)
      { 
       RESULTS=realloc(RESULTS, (i+1) * sizeof(int));    //assignation memoire RESULT
       SubFolderNames[i] = malloc (strlen (folder->d_name) + 1); //Assignation mémoire SubFolderNames[i]
 
       if (strlen(FULLPATH) < (strlen(SubFolderNames[i])+strlen(PATH)+1))  //|Assignation de mémoire 
          {                                                                //|pour FULLPATH si plus grand que 
          FULLPATH= realloc (FULLPATH,(strlen(SubFolderNames[i])+ strlen(PATH)+1)*sizeof(char));
          }
      if (SubFolderNames[i] != NULL)                                        
         {
         strcpy(SubFolderNames[i],folder->d_name);  //On recupère le nom du ième sous dossier dans SubFolderNames
         }  
       else {printf("\nNo more memory available\n"); system("pause"); }     
       RESULTS[i]=0;    
       sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[i]);   //On stocke le chemin du sous dossier en cours dans FullPATH       
       if (Project_Or_Not(FULLPATH) || !strcmp(SubFolderNames[i],"_Common"))    //Si le sous dossier est un projet ou un dossier Common
          {
          State=Add_Folder (FULLPATH);          //On le zippe
 
          if (State!=0) {fprintf(Log,"%s\n",FULLPATH);State=0;} //si erreur pendant la compression -> log
          else {
               CmdLine = realloc (CmdLine, (strlen(FULLPATH)+20)* sizeof(char));     //memoire pour CmdLine
               if (CmdLine!=NULL)
                  {
                  sprintf(CmdLine,"rd /S /Q \"%s\"",FULLPATH);State=system(CmdLine);//suppression du dossier 
                  }
               else {printf("\nNo more memory available\n"); system("pause"); }
               }     
          if (State!=0) {fprintf(Log,"%s\n",FULLPATH);}      //Si erreur pendant la supression ->log
 
          RESULTS[i]=1;        
          }
       else
          {
         if (opendir(FULLPATH))                
             {
             RESULTS[i]=arbo(FULLPATH); //appelle la fonction sur les sous dossiers
             }           
          else
             {
             RESULTS[i]=0;  
             }
          }
      } //fin de if (i>1) 
   i++; 
   }//Fin de la boucle qui traite les sous dossiers 
if (i==1) return 0;//Si le dossier est vide on renvoie 0
 
//Cette boucle compte les 0 et les 1 renvoyés par l'appel de la fonction sur les sous dossier du dossier en cours
for (j=2;j<i;j++)
    {
    if (j%STEP ==2) {FoldersNotZipped = realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));}
    if (RESULTS[j]==0) 
       {
       sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[j]);   //|On stocke le chemin du sous dossier en cours dans FullPATH  
       FoldersNotZipped[z]=  malloc ((strlen(FULLPATH)+1)* sizeof(char)); 
       if (FoldersNotZipped[z] != NULL)
        {//On stocke les chemins associé a un 0 dans le tableau FoldersNotZipped
         strcpy(FoldersNotZipped[z],FULLPATH); //On recupère le nom du ième sous dossier dans SubFolderNames
        }  
       else {printf("\nNo more memory available\n"); system("pause"); }         
       z++;
       }
    else 
       {
       u++;
       }
    }//fin de for (j=2;j<i;j++)
//Liberation des mémoires reservées
free (SubFolderNames);
free (RESULTS);
free (PATH);
//En fonction des valeurs renvoyées par les sous dossiers, on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier
if (u==0) {free(FoldersNotZipped); return 0; }
if (z==0) {free(FoldersNotZipped);return 1; }
if (u!=0 && z!=0)
     {      
      for (i=0;i<z;i++)
          {  
           if (opendir(FoldersNotZipped[i])) {fprintf(Log,"%s\n",FoldersNotZipped[i]);}
          ToCheck++;
          }     
      free(FoldersNotZipped);
      return 1;          
     }
 
}//fin de la fonction arbo
 
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
//---------------------------------------------------------------------------------------------------------------------------\\
 
 
int main (int argc, char *argv[])
{
char CmdLine[256];
 
clock_t
  temps_initial, /* Temps initial en micro-secondes */
  temps_final;   /* Temps final en micro-secondes */
 
float
  temps_cpu;    /* Temps total en micro-secondes */   
 
Log = fopen("c:\\windows\\temp\\log.txt", "w+");                 //| 
                                                                 //| 
   if (Log == NULL) {                                            //| Ouverture du  fichier de logs
		fprintf(stderr,"The Log file could not be created");     //| 
		system("pause");exit(-1);                                //| 
	}   
  Copy_wzzip();   //crée une copie de wzzip (sans espace dans le chemin)
 
  temps_initial = clock ();  //Prends l'heure de départ
 
  arbo(argv[1]);  //appelle la fonction qui parcours l'arborescence
 
  fclose(Log);	//Ferme le fichier de logs
  temps_final = clock ();    //Prends l'heure de fin	
 
  temps_cpu = (temps_final - temps_initial) * 1e-3;  //calcule le temps ecoulé et le convertit en secondes
 
  printf("\ntemps : %.2f\n",temps_cpu);  	
 
  system ("del c:\\windows\\temp\\wzzip.exe");
  if (ToCheck!=0){ sprintf(CmdLine,"Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\""); system(CmdLine);}
 
  system("PAUSE");
 
  return 0;
 
}

Ah oui, je n'ai pas précisé mais ce code doit tourner sous windows, la compatibilité n'est donc pas une priorité.
J'utilises DEVC++ pour compiler.
Les prerequis pour l'utilisation du tool sont
-Winzip Pro 10 ou 11
-Winzip Command Line 2

Merci d'avance

[granquet]

quantitée de code limitée ne veux pas dire code non compilable

[Emmanuel Delahaye]

<...>jetter un oeil sur mon travail d'amateur, je ne vais pas me priver :

Pas mal de choses à mettre au point avant de continer :

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:14:1: warning: multi-line comment
main.c:39:1: warning: multi-line comment
main.c:49:1: warning: multi-line comment
main.c: In function `Add_Folder':
main.c:69: warning: comparison between signed and unsigned
main.c:93:1: warning: multi-line comment
main.c:211:1: warning: multi-line comment
main.c: At top level:
main.c:216: warning: unused parameter 'argc'
main.c: In function `Copy_wzzip':
main.c:47: warning: control reaches end of non-void function
main.c: In function `arbo':
main.c:209: warning: control reaches end of non-void function
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 7 seconds)
0 errors, 9 warnings

Si ton compilateur ne dit rien, il est sans doute mal réglé :

http://emmanuel-delahaye.developpez....tm#cfg_compilo

Quelque remarques sur ton code :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
 
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <dirent.h>
 
#define STEP 15
 
/* -ed- des globales, ? */
FILE *Log;                      /* Declaration fichier log */
int ToCheck = 0;
int Length = 0;
 
/* -ed- les commentaires, c'est bien, mais ils doivent rester lisibles
        et de pas depasser 80 colonnes.
        '//' n'est pas conforme a C 90. */
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction determine si un dossier est un projet ou pas */
int Project_Or_Not (char *FULLPATH)
{
   /* |Déclaration de la structure qui contiendra le dossier en cours */
   struct dirent *lecture;
   DIR *rep;
   /* Chaine temporaire */
   char TEMP[256];
 
   /* Ouvre les sous dossiers de PATH */
   rep = opendir (FULLPATH);
 
/* -ed- la definition d'une variable apres une fonction
        n'est pas conforme a C90. */
   int sub = 0;
 
   while ((lecture = readdir (rep)))
   {
      /* On lit le nom de chaque sous dossier */
      sprintf (TEMP, "%s", lecture->d_name);
      /* Si il a un des noms suivant, on incrémente le compteur "sub".
         From_Cust, To_Cust, WORK, Admin sont des sous dossiers d'un projet */
      if (!strcmp (TEMP, "From_Cust"))
         sub++;
      if (!strcmp (TEMP, "To_Cust"))
         sub++;
      if (!strcmp (TEMP, "WORK"))
         sub++;
      if (!strcmp (TEMP, "Admin"))
         sub++;
   }
 
   if (sub >= 2)
      return 1;
   return 0;
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction copie l'exe de winzip dans c:\windows\temp,
   afin de le lancer d'un chemin sans espace (pose des problèmes sinon) */
 
/* -ed- ne retourne rien : void. */
void Copy_wzzip (void)
{
   /* crée une copie de winzip dans c:\windows\temp */
   system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction zippera un dossier dont le chemin contiendra
   le code d'erreur */
int Add_Folder (char *FULLPATH)
{
   int Code;
   int i;
   int j;
   /* Contiendra le nom du projet */
   char NAME[strlen (FULLPATH)];
   /* Contient le chemin sans le nom de projet */
   char SHORTPATH[strlen (FULLPATH)];
   /* Contiendra les Ligne de Commande passées au système */
   char CmdLine[strlen (FULLPATH) + 40];
 
   /* -ed- qui dit que la taille est suffisante ?
      L'allocation dynamique est plus sure (strdup(),
      par exemple, qui est POSIX.1, donc tres portable) */
   strcpy (SHORTPATH, FULLPATH);
 
   /* -ed- c'est pas une bonne idee de mettre une
      fonction dans une boucle, surtout si
      c'est un invariant. Perte de temps.
 
      Pour faire ce genre de recherche,
      envisager strchr() ou strrchr()...
    */
   /* Cette boucle parcours la chaine a l'envers */
   for (i = (strlen (SHORTPATH) - 1); i >= 0; i--)
   {
      if (SHORTPATH[i] == '\\') /* si on tombe sur un "\" on va remplace */
      {
         for (j = i + 1; j <= strlen (SHORTPATH); j++) /* Cette boucle extrait le nom de dossier */
         {
            NAME[j - (i + 1)] = SHORTPATH[j]; /* Copie caractère par caractère */
         }
         SHORTPATH[i] = '\0';
         i = -1;
      }
   }
 
   /* preparation de la ligne de commande qui lance la Compression */
   sprintf (CmdLine, "C:\\windows\\temp\\wzzip.exe"
            " -r -p -whs -en \"%s\\%s.zip\" \"%s\"",
            SHORTPATH, NAME, FULLPATH);
 
   /* on recupere le code d'état renvoyé par la ligne de commande */
   Code = system (CmdLine);
 
   /* Ajouter la ligne qui efface le dossier */
 
#if 0
/* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
 
   /* Liberation de l'espace memoire reservé pour les chaines */
   free (SHORTPATH);
   free (CmdLine);
   free (NAME);
#endif
 
   return Code;                 /* retourne le code d'état */
 
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
int arbo (char *PATH)
/* Cette fonction parcoureras l'arborescence à la recherche de projets
   et essaiera de zipper les projets qu'elle trouve
   Prends le chemin du dossier à analyser en paramètre,
   et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé */
{
 
   int i = 0;
   int j;
   int z = 0;
   int u = 0;
 
/* -ed- sizeof(char) vaut 1 par definition.
        Pourquoi allouer 1 caractere ?
        Autant laisser NULL. */
   char *CmdLine = malloc (sizeof (char));
   /* Contiendra le chemin complet du dossier en cours */
   char *FULLPATH = malloc (sizeof (char));
   /* contiendra une valeur associée a un dossier
      (RESULTS[i] associé a SubFolderNames[i]) */
   int *RESULTS = NULL;
   int State;                   /* Code d'état (zip+rd) */
 
   /* Contient tous les sous dossiers du dossier en cours */
   char **SubFolderNames = NULL;
   /* Contient les sous dossiers dont la valeur associée est 0 */
   char **FoldersNotZipped = NULL;
 
   /* Déclaration de la structure qui contiendra le dossier en cours */
   struct dirent *folder;
   DIR *rep;
   rep = opendir (PATH);        /* Ouvre les sous dossiers de rep */
 
   /* boucle qui traite tous les sous dossiers */
   while ((folder = readdir (rep)))
   {
      if (i % STEP == 2)
      {
         /* Assignation mémoire SubFolderNames */
         SubFolderNames =
            realloc (SubFolderNames, (i + STEP) * sizeof (char *));
      }
      if (i > 1)                /* si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas) */
      {
         /* assignation memoire RESULT */
         RESULTS = realloc (RESULTS, (i + 1) * sizeof (int));
         /* Assignation mémoire SubFolderNames[i] */
         SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
 
         /* Assignation de mémoire pour FULLPATH si plus grand que */
         if (strlen (FULLPATH) <
             (strlen (SubFolderNames[i]) + strlen (PATH) + 1))
         {
            FULLPATH =
               realloc (FULLPATH,
                        (strlen (SubFolderNames[i]) + strlen (PATH) +
                         1) * sizeof (char));
         }
         if (SubFolderNames[i] != NULL)
         {
            /* On recupère le nom du ième sous dossier dans SubFolderNames */
            strcpy (SubFolderNames[i], folder->d_name);
         }
         else
         {
            printf ("\nNo more memory available\n");
            system ("pause");
         }
         RESULTS[i] = 0;
         /* On stocke le chemin du sous dossier en cours dans FullPATH */
         sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[i]);
 
         /* Si le sous dossier est un projet ou un dossier Common */
         if (Project_Or_Not (FULLPATH)
             || !strcmp (SubFolderNames[i], "_Common"))
         {
            State = Add_Folder (FULLPATH); /* On le zippe */
 
            if (State != 0)
            {
               fprintf (Log, "%s\n", FULLPATH);
               State = 0;
            }                   /* si erreur pendant la compression -> log */
            else
            {
               /* memoire pour CmdLine */
               CmdLine =
                  realloc (CmdLine, (strlen (FULLPATH) + 20) * sizeof (char));
               if (CmdLine != NULL)
               {
                  sprintf (CmdLine, "rd /S /Q \"%s\"", FULLPATH);
                  State = system (CmdLine); /* suppression du dossier */
               }
               else
               {
                  printf ("\nNo more memory available\n");
                  system ("pause");
               }
            }
            if (State != 0)
            {
               fprintf (Log, "%s\n", FULLPATH);
            }                   /* Si erreur pendant la supression ->log */
 
            RESULTS[i] = 1;
         }
         else
         {
            if (opendir (FULLPATH))
            {
               /* appelle la fonction sur les sous dossiers */
               RESULTS[i] = arbo (FULLPATH);
            }
            else
            {
               RESULTS[i] = 0;
            }
         }
      }                         /* fin de if (i>1) */
      i++;
   }                            /* Fin de la boucle qui traite les sous dossiers */
   if (i == 1)
      return 0;                 /* Si le dossier est vide on renvoie 0 */
 
   /* Cette boucle compte les 0 et les 1 renvoyés par
      l'appel de la fonction sur les sous dossier du
      dossier en cours */
   for (j = 2; j < i; j++)
   {
      if (j % STEP == 2)
      {
         FoldersNotZipped =
            realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));
      }
      if (RESULTS[j] == 0)
      {
         /* On stocke le chemin du sous dossier en cours dans FullPATH */
         sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[j]);
         FoldersNotZipped[z] =
            malloc ((strlen (FULLPATH) + 1) * sizeof (char));
         if (FoldersNotZipped[z] != NULL)
         {
            /* On stocke les chemins associé a un 0 dans le
               tableau FoldersNotZipped
               On recupère le nom du ième sous dossier dans SubFolderNames */
            strcpy (FoldersNotZipped[z], FULLPATH);
         }
         else
         {
            printf ("\nNo more memory available\n");
            system ("pause");
         }
         z++;
      }
      else
      {
         u++;
      }
   }                            /* fin de for (j=2;j<i;j++) */
/* Liberation des mémoires reservées */
   free (SubFolderNames);
   free (RESULTS);
   free (PATH);
/* En fonction des valeurs renvoyées par les sous dossiers,
   on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier */
   if (u == 0)
   {
      free (FoldersNotZipped);
      return 0;
   }
   if (z == 0)
   {
      free (FoldersNotZipped);
      return 1;
   }
   if (u != 0 && z != 0)
   {
      for (i = 0; i < z; i++)
      {
         if (opendir (FoldersNotZipped[i]))
         {
            fprintf (Log, "%s\n", FoldersNotZipped[i]);
         }
         ToCheck++;
      }
      free (FoldersNotZipped);
      return 1;
   }
 
/* -ed- DANGER ! Fonction douteuse.
        Il y a possibilite de quitter cette fonction
        recursive sans retourner une valeur valide.
 
        Risque de comportement indefini.
 
        D'une maniere generale, les returns multiples
        sont un risque pour le programme et nuisent à
        la lecture et à la qualité du code. */
 
}
 
/* fin de la fonction arbo */
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
int main (int argc, char *argv[])
{
   /* --ed- argc n'est pas utilise,
      ce qui signifie que le nombre de parametres
      n'est pas controle. Il y a un risque important
      de comportement indéfini */
 
   char CmdLine[256];
 
   clock_t temps_initial,       /* Temps initial en micro-secondes */
     temps_final;               /* Temps final en micro-secondes */
 
   /* -ed- pourquoi float alors que le calcul se fait en double ? */
   float temps_cpu;             /* Temps total en micro-secondes */
 
   Log = fopen ("c:\\windows\\temp\\log.txt", "w+"); /* | */
   /* | */
   if (Log == NULL)
   {                            /* | Ouverture du  fichier de logs */
      fprintf (stderr, "The Log file could not be created"); /* | */
      system ("pause");
      exit (-1);                /* | */
   }
   Copy_wzzip ();               /* crée une copie de wzzip (sans espace dans le chemin) */
 
   temps_initial = clock ();    /* Prends l'heure de départ */
 
   arbo (argv[1]);              /* appelle la fonction qui parcours l'arborescence */
 
   fclose (Log);                /* Ferme le fichier de logs */
   temps_final = clock ();      /* Prends l'heure de fin */
 
   /* -ed- Les calculs de temps doivent etre faits
      avec CLOCKS_PER_SEC et non une constante
      tiree d'un chapeau... */
   /* calcule le temps ecoulé et le convertit en secondes */
   temps_cpu = (temps_final - temps_initial) * 1e-3;
 
   printf ("\ntemps : %.2f\n", temps_cpu);
 
   system ("del c:\\windows\\temp\\wzzip.exe");
   if (ToCheck != 0)
   {
      sprintf (CmdLine,
               "Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\"");
      system (CmdLine);
   }
 
   system ("PAUSE");
 
   return 0;
}

[alexinho]

Merci beaucoup pour tes conseils, je vais essayer d'améliorer le code en revoyant tout ça. Je te donnerais des nouvelles

[alexinho]

j'ai fait de mon mieux pour améliorer les choses, mais ça bug toujours!
Tu peux jetter un oeil?

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <dirent.h>
 
#define STEP 15
 
/* -ed- des globales, ? */
/* -Al- c'est problèmatique ?*/
 
FILE *Log;                      /* Declaration fichier log */
 
 
/* -ed- les commentaires, c'est bien, mais ils doivent rester lisibles
        et de pas depasser 80 colonnes.
        '//' n'est pas conforme a C 90. */
/* -Al- Merci pour ton travail de mise en page :) */  
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction determine si un dossier est un projet ou pas */
int Project_Or_Not (char *FULLPATH)
{
   /* Déclaration de la structure qui contiendra le dossier en cours */
   struct dirent *lecture;
   DIR *rep;
   /* Chaine temporaire */
   char TEMP[256];
   int sub = 0;
   /* Ouvre les sous dossiers de PATH */
   rep = opendir (FULLPATH);
/* -ed- la definition d'une variable apres une fonction
        n'est pas conforme a C90. */
/* -Al- Mis à jour */        
 
 
   while ((lecture = readdir (rep)))
   {
      /* On lit le nom de chaque sous dossier */
      sprintf (TEMP, "%s", lecture->d_name);
      /* Si il a un des noms suivant, on incrémente le compteur "sub".
         From_Cust, To_Cust, WORK, Admin sont des sous dossiers d'un projet */
      if (!strcmp (TEMP, "From_Cust"))
         sub++;
      if (!strcmp (TEMP, "To_Cust"))
         sub++;
      if (!strcmp (TEMP, "WORK"))
         sub++;
      if (!strcmp (TEMP, "Admin"))
         sub++;
   }
 
   if (sub >= 2)  /*si il y a au moins 2 de ces sous dossiers*/
      return 1;
   return 0;     /*retourne 0 sinon*/
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction copie l'exe de winzip dans c:\windows\temp,
   afin de le lancer d'un chemin sans espace (pose des problèmes sinon) */
 
/* -ed- ne retourne rien : void. */
void Copy_wzzip (void)
{
   /* crée une copie de winzip dans c:\windows\temp */
   system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction zippera un dossier dont le chemin contiendra
   le code d'erreur */
int Add_Folder (char *FULLPATH)
{
   int Code;
   int i;
   int j;
   int l;
   /* Contiendra le nom du projet */
   char NAME[256];
   /* Contient le chemin sans le nom de projet */
   char *SHORTPATH = NULL;
   /* Contiendra les Ligne de Commande passées au système */
   char *CmdLine;
 
   /* -ed- qui dit que la taille est suffisante ?
      L'allocation dynamique est plus sure (strdup(),
      par exemple, qui est POSIX.1, donc tres portable) */ 
   /* -Al- Mis à jour */
   SHORTPATH=strdup(FULLPATH);
 
   /* -ed-  c'est pas une bonne idee de mettre une
      fonction dans une boucle, surtout si
      c'est un invariant. Perte de temps.
      
      Pour faire ce genre de recherche,
      envisager strchr() ou strrchr()...
    */
   /* -Al- Je ne connaissais pas ces fontions, elles m'ont l'air plutôt utile 
      effectivement, j'essaierais de changer ça quand j'aurais un code qui 
      fonctionne. 
      J'ai corrigé le problème du strlen appelé en boucle, effectivement c'est
      une perte de temps */
 
   /* Cette boucle parcours la chaine a l'envers */
   l=strlen (SHORTPATH);
   for (i = (l - 1); i >= 0; i--)
   {
      if (SHORTPATH[i] == '\\') /* si on tombe sur un "\" on va remplace par \0*/
      {
         /* Cette boucle extrait le nom de dossier */
         for (j = i + 1; j <= l; j++) 
         {
            NAME[j - (i + 1)] = SHORTPATH[j]; /* Copie caractère par caractère */
         }
         SHORTPATH[i] = '\0';
         i = -1;
      }
   }
   CmdLine = malloc ((strlen(FULLPATH)+strlen(SHORTPATH)+80)*sizeof(char));
   /* preparation de la ligne de commande qui lance la Compression */
   sprintf (CmdLine, "C:\\windows\\temp\\wzzip.exe"
            " -r -p -whs -en \"%s\\%s.zip\" \"%s\"",
            SHORTPATH, NAME, FULLPATH);
 
   /* on recupere le code d'état renvoyé par la ligne de commande */
   Code = system (CmdLine);
 
   /* Ajouter la ligne qui efface le dossier */
 
 
 
/* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
/* -Al- Mis à jour */ 
   /* Liberation de l'espace memoire reservé pour les chaines */
   if(SHORTPATH != NULL) free (SHORTPATH);
   if(CmdLine != NULL) free (CmdLine);
   if (NAME != NULL) free (NAME);
 
   return Code;                 /* retourne le code d'état */
 
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
int arbo (char *PATH)
/* Cette fonction parcoureras l'arborescence à la recherche de projets
   et essaiera de zipper les projets qu'elle trouve
   Prends le chemin du dossier à analyser en paramètre,
   et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé */
{
 
   int i = 0;
   int j;
   int z = 0;
   int u = 0;
 
   /* -ed- sizeof(char) vaut 1 par definition.
        Pourquoi allouer 1 caractere ?
        Autant laisser NULL. */
   /* -Al- Mis à jour*/     
   char *CmdLine = NULL;
   /* Contiendra le chemin complet du dossier en cours */
   char *FULLPATH = NULL;
   /* contiendra une valeur associée a un sous dossier
      (RESULTS[i] associé a SubFolderNames[i]) */
   int *RESULTS = NULL;
   int State;           /* Code d'état (zip+rd) */
 
   /* Contient tous les sous dossiers du dossier en cours */
   char **SubFolderNames = NULL;
   /* Contient les sous dossiers dont la valeur associée est 0 */
   char **FoldersNotZipped = NULL;
 
   /* Déclaration de la structure qui contiendra le dossier en cours */
   struct dirent *folder;
   DIR *rep;
   rep = opendir (PATH);        /* Ouvre les sous dossiers de rep */
 
   /* boucle qui traite tous les sous dossiers */
   while ((folder = readdir (rep)))
   {
      if (i % STEP == 2)
      {
         /* Assignation mémoire SubFolderNames */
         SubFolderNames =
            realloc (SubFolderNames, (i + STEP) * sizeof (char *));
      }
      if (i > 1)      
      /* si i=0 d_name=. et si i=1 d_name=.. (la procédure ne s'applique pas) */
      {
         /* assignation memoire RESULT */
         RESULTS = realloc (RESULTS, (i + 1) * sizeof (int));
         /* Assignation mémoire SubFolderNames[i] */
         SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
 
         /* Assignation de mémoire pour FULLPATH si plus grand que */
         if (strlen (FULLPATH) <
             (strlen (SubFolderNames[i]) + strlen (PATH) + 1))
         {
            FULLPATH =
               realloc (FULLPATH,
                        (strlen (SubFolderNames[i]) + strlen (PATH) +
                         1) * sizeof (char));
         }
         if (SubFolderNames[i] != NULL)
         {
            /* On recupère le nom du ième sous dossier dans SubFolderNames */
            strcpy (SubFolderNames[i], folder->d_name);
         }
         else
         {
            printf ("\nNo more memory available\n");
            system ("pause");
            exit (-1);
         }
         RESULTS[i] = 0;
         /* On stocke le chemin du sous dossier en cours dans FullPATH */
         sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[i]);
 
         /* Si le sous dossier est un projet ou un dossier Common */
         if (Project_Or_Not (FULLPATH)
             || !strcmp (SubFolderNames[i], "_Common"))
         {
            State = Add_Folder (FULLPATH); /* On le zippe */
 
            if (State != 0)
            {
               fprintf (Log, "%s\n", FULLPATH);
               State = 0;
            }                   /* si erreur pendant la compression -> log */
            else
            {
               /* memoire pour CmdLine */
               CmdLine =
                  realloc (CmdLine, (strlen (FULLPATH) + 20) * sizeof (char));
               if (CmdLine != NULL)
               {
                  sprintf (CmdLine, "rd /S /Q \"%s\"", FULLPATH);
                  State = system (CmdLine); /* suppression du dossier */
               }
               else
               {
                  printf ("\nNo more memory available\n");
                  system ("pause");
                  exit (-1);
               }
            }
            if (State != 0)
            {
               fprintf (Log, "%s\n", FULLPATH);
            }                   /* Si erreur pendant la supression ->log */
 
            RESULTS[i] = 1;
         }
         else
         {
            if (opendir (FULLPATH))
            {
               /* appelle la fonction sur les sous dossiers */
               RESULTS[i] = arbo (FULLPATH);
            }
            else
            {
               RESULTS[i] = 0;
            }
         }
      }                         /* fin de if (i>1) */
      i++;
   }                          /* Fin de la boucle qui traite les sous dossiers*/
 
   /* Cette boucle compte les 0 et les 1 renvoyés par
      l'appel de la fonction sur les sous dossier du
      dossier en cours */
   for (j = 2; j < i; j++)
   {
      if (j % STEP == 2)
      {
         FoldersNotZipped =
            realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));
      }
      if (RESULTS[j] == 0)
      {
         /* On stocke le chemin du sous dossier en cours dans FullPATH */
         sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[j]);
         FoldersNotZipped[z] =
            malloc ((strlen (FULLPATH) + 1) * sizeof (char));
         if (FoldersNotZipped[z] != NULL)
         {
            /* On stocke les chemins associé a un 0 dans le
               tableau FoldersNotZipped
               On recupère le nom du ième sous dossier dans SubFolderNames */
            strcpy (FoldersNotZipped[z], FULLPATH);
         }
         else
         {
            printf ("\nNo more memory available\n");
            system ("pause");
            exit (-1);
         }
         z++;
      }
      else
      {
         u++;
      }
   }             /* fin de for (j=2;j<i;j++) */
/* Liberation des mémoires reservées */
  free (SubFolderNames);
  free (RESULTS);
 
/* En fonction des valeurs renvoyées par les sous dossiers,
   on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier */
   if (u == 0)
   {
      free (FoldersNotZipped);
      return 0;
   }
 
   for (i = 0; i < z; i++)
    {
     if (opendir (FoldersNotZipped[i]))
     {
        fprintf (Log, "%s\n", FoldersNotZipped[i]);
     }
 
    }
    free (FoldersNotZipped);
    return 1;
 
}
 /* -ed- DANGER ! Fonction douteuse.
        Il y a possibilite de quitter cette fonction
        recursive sans retourner une valeur valide.
 
        Risque de comportement indefini.
 
        D'une maniere generale, les returns multiples
        sont un risque pour le programme et nuisent à
        la lecture et à la qualité du code. */
 /* -Al- Mis à jour : Est-ce suffisemment simplifié?*/ 
 
/* fin de la fonction arbo */
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
int main (int argc, char *argv[])
{
   /* --ed- argc n'est pas utilise,
      ce qui signifie que le nombre de parametres
      n'est pas controle. Il y a un risque important
      de comportement indéfini */
   /* -Al- Mis à jour */   
   char CmdLine[256];
 
   clock_t temps_initial,       /* Temps initial en micro-secondes */
     temps_final;               /* Temps final en micro-secondes */
 
   /* -ed- pourquoi float alors que le calcul se fait en double ? */
   /* -Al- Mis à jour */
   double temps_cpu;             /* Temps total en micro-secondes */
 
   Log = fopen ("c:\\windows\\temp\\log.txt", "w+"); 
 
   if (Log == NULL)
   {                            /* Ouverture du  fichier de logs */
      fprintf (stderr, "The Log file could not be created"); 
      system ("pause");
      exit (-1);                
   }
   Copy_wzzip ();     /* crée une copie de wzzip (sans espace dans le chemin) */
 
   temps_initial = clock ();    /* Prends l'heure de départ */
 
   if (argc==2) 
      arbo (argv[1]);       /* appelle la fonction qui parcours l'arborescence*/
   else 
      printf("Please check arguments\n");
 
   fclose (Log);                /* Ferme le fichier de logs */
   temps_final = clock ();      /* Prends l'heure de fin */
/* -ed- Les calculs de temps doivent etre faits
      avec CLOCKS_PER_SEC et non une constante
      tiree d'un chapeau... */
/* -Al- Mis à jour */
 
   /* calcule le temps ecoulé et le convertit en secondes */
   temps_cpu = (temps_final - temps_initial) / CLOCKS_PER_SEC;
 
   printf ("\ntemps : %d\n", temps_cpu);
 
   system ("del c:\\windows\\temp\\wzzip.exe");
 
   sprintf (CmdLine,
          "Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\"");
   system (CmdLine);
 
 
   system ("PAUSE");
 
   return 0;
}

[Emmanuel Delahaye]

J'ai toujours le même soucis avec mon code... ça crash

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
 
 
/* Cette fonction zippera un dossier dont le chemin contiendra
   le code d'erreur */
int Add_Folder (char *FULLPATH)
{
   /* Contiendra le nom du projet */
   char NAME[256];
   /* Contient le chemin sans le nom de projet */
   char *SHORTPATH = NULL;
   /* Contiendra les Ligne de Commande passées au système */
   char CmdLine[strlen (FULLPATH) + 40];
 
   /* -Al- Mis à jour */
   SHORTPATH=strdup(FULLPATH);
 
/* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
/* -Al- Mis à jour */ 
   /* Liberation de l'espace memoire reservé pour les chaines */
   if(SHORTPATH != NULL) free (SHORTPATH);
   if(CmdLine != NULL) free (CmdLine);
   if (NAME != NULL) free (NAME);

Tu n'as rien corrigé du tout, ou presque...

OK, pour SHORTPATH (majuscule, on ne sait pas pourquoi...). strdup() utilise malloc(), donc free. (inutile de faire e test à NULL, free(NULL) est défini et sans danger).

Mais tu penses sincèrement que CmdLine et NAME ont été alloués par malloc() ?

[alexinho]

Quand tu dis "tu n'a rien corrigé du tout" tu parles de l'ensemble des erreurs que tu m'a signalées ou de celle ci uniquement?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
 
/* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
/* -Al- Mis à jour */ 
   /* Liberation de l'espace memoire reservé pour les chaines */
   free (SHORTPATH);
 
 
   return Code;                 /* retourne le code d'état */
 
}

[Emmanuel Delahaye]

Quand tu dis "tu n'a rien corrigé du tout" tu parles de l'ensemble des erreurs que tu m'a signalées ou de celle ci uniquement?

Celle-ci uniquement. Oui, j'ai vu que tu avais corrigé le reste.

Alors, ça plante toujours ?

[alexinho]

J'ai trouvé plusieurs autres problèmes, dont un que je n'arrive pas à comprendre. J'arrive à faire marcher le programme en utilisant une constante pour allouer de la memoire, donc c'est pas vraiment un soucis en soit.
Pourtant pour le coté pedagogique j'aimerais bien que tu m'explique ce qui ne va pas si tu arrives a comprendre.
J'ai mis en évidence le problème dans le code (vers la ligne 190):

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <dirent.h>
 
#define STEP 15
 
 
 
FILE *Log;                      /* Declaration fichier log */
int ToCheck = 0;
 
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction determine si un dossier est un projet ou pas */
int ProjectOrNot (char *FullPath)
{
 
   /* Déclaration de la structure qui contiendra le dossier en cours */
   struct dirent *lecture;
   DIR *rep;
   /* Chaine temporaire */
   char TEMP[256];
   int sub = 0;
   /* Ouvre les sous dossiers de Path */
   rep = opendir (FullPath);
 
   while ((lecture = readdir (rep)))
   {
      /* On lit le nom de chaque sous dossier */
      sprintf (TEMP, "%s", lecture->d_name);
      /* Si il a un des noms suivant, on incrémente le compteur "sub".
         From_Cust, To_Cust, WORK, Admin sont des sous dossiers d'un projet */
      if (!strcmp (TEMP, "From_Cust"))
         sub++;
      if (!strcmp (TEMP, "To_Cust"))
         sub++;
      if (!strcmp (TEMP, "WORK"))
         sub++;
      if (!strcmp (TEMP, "Admin"))
         sub++;
   }
 
   if (sub >= 2)  /*si il y a au moins 2 de ces sous dossiers*/
      return 1;
 
   return 0;     /*retourne 0 sinon*/
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction copie l'exe de winzip dans c:\windows\temp,
   afin de le lancer d'un chemin sans espace (pose des problèmes sinon) */
 
void Copy_wzzip (void)
{
   /* crée une copie de winzip dans c:\windows\temp */
   system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
/* Cette fonction zippera un dossier dont le chemin contiendra
   le code d'erreur */
int Add_Folder (char *FullPath)
{
   int Code;
   int i;
   int j;
   int l;
   /* Contiendra le nom du projet */
   char Name[256];
   /* Contient le chemin sans le nom de projet */
   char *ShortPath = NULL;
   /* Contiendra les Ligne de Commande passées au système */
   char *CmdLine = NULL;
 
   ShortPath=strdup(FullPath);
 
   /* Cette boucle parcours la chaine a l'envers */
   l=strlen (ShortPath);
   for (i = (l - 1); i >= 0; i--)
   {
      if (ShortPath[i] == '\\') /* si on tombe sur un "\" on va remplace par \0*/
      {
         /* Cette boucle extrait le nom de dossier */
         for (j = i + 1; j <= l; j++) 
         {
            Name[j - (i + 1)] = ShortPath[j]; /* Copie caractère par caractère */
         }
         ShortPath[i] = '\0';
         i = -1;
      }
   }
   CmdLine = malloc ((strlen(FullPath)+strlen(ShortPath)+strlen(Name)+80)*sizeof(char));
   /* preparation de la ligne de commande qui lance la Compression */
   sprintf (CmdLine, "C:\\windows\\temp\\wzzip.exe"
            " -r -p -whs -en \"%s\\%s.zip\" \"%s\"",
            ShortPath, Name, FullPath);
 
   /* on recupere le code d'état renvoyé par la ligne de commande */
   Code = system (CmdLine);
 
   /* Liberation de l'espace memoire reservé pour les chaines */
   free (ShortPath);
 
   return Code;                 /* retourne le code d'état */
 
}
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
int arbo (char *Path)
/* Cette fonction parcoureras l'arborescence à la recherche de projets
   et essaiera de zipper les projets qu'elle trouve
   Prends le chemin du dossier à analyser en paramètre,
   et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé */
{
   int a = 0;
   int i = 0;
   int j;
   int z = 0;
   int u = 0;
 
   char *CmdLine = NULL;
   /* Contiendra le chemin complet du dossier en cours */
   /*On assigne une valeur a FullPath sinon strlen(FullPath) plantera par la suite*/
   char *FullPath = malloc(100);  
   /* contiendra une valeur associée a un sous dossier
      (RESULTS[i] associé a SubFolderNames[i]) */
   int *RESULTS = NULL;
   int State;           /* Code d'état (zip+rd) */
 
   /* Contient tous les sous dossiers du dossier en cours */
   char **SubFolderNames = NULL;
   /* Contient les sous dossiers dont la valeur associée est 0 */
   char **FoldersNotZipped = NULL;
 
   /* Déclaration de la structure qui contiendra le dossier en cours */
   struct dirent *folder;
   DIR *rep;
   rep = opendir (Path);        /* Ouvre les sous dossiers de rep */
 
   /*On assigne une valeur a FullPath sinon strlen(FullPath) plantera par la suite*/
   FullPath = malloc(20);  
   /* boucle qui traite tous les sous dossiers */
   while ((folder = readdir (rep)))
   {
      if (i % STEP == 2)
      {
         /* Assignation mémoire SubFolderNames */
         SubFolderNames =
            realloc (SubFolderNames, (i + STEP) * sizeof (char *));
      }
      if (i > 1)      
      /* si i=0 d_name=. et si i=1 d_name=.. (la procédure ne s'applique pas) */
      {
         /* assignation memoire RESULT */
         RESULTS = realloc (RESULTS, (i + 1) * sizeof (int));
         /* Assignation mémoire SubFolderNames[i] */
 
         SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
         if (SubFolderNames[i] != NULL)
         {
            /* On recupère le nom du ième sous dossier dans SubFolderNames */
            strcpy (SubFolderNames[i], folder->d_name);
         }
         else
         {
            printf ("\nNo more memory available\n");
            system ("pause");
            exit (-1);
         }
        RESULTS[i] = 0;
         /* Assignation de mémoire pour FullPath  */
 
           if (strlen (FullPath) <
             strlen (SubFolderNames[i]) + strlen("\\")+ strlen (Path) +1)
         {
     /***********************************************************************
     Ce code occasionne un plantage             
            FullPath =
               realloc (FullPath,
                   strlen (SubFolderNames[i]) + strlen (Path) + strlen("\\")+1);
         
     ***********************************************************************/ 
      /*Ce code tourne*/
            FullPath =
               realloc (FullPath,1000);
 
     /***********************************************************************/          
         }               
         /* On stocke le chemin du sous dossier en cours dans FullPath */
         sprintf (FullPath, "%s\\%s", Path, SubFolderNames[i]);
 
         /* Si le sous dossier est un projet ou un dossier Common */
         if (opendir (FullPath))
         {
             a=ProjectOrNot (FullPath);
         }
         if (a!=0
             || !strcmp (SubFolderNames[i], "_Common"))
         {
            State = Add_Folder (FullPath); /* On le zippe */
 
            if (State != 0)
            {
               fprintf (Log, "%s\n", FullPath);
               ToCheck++;
               State = 0;
            }                   /* si erreur pendant la compression -> log */
            else
            {
               /* memoire pour CmdLine */
               CmdLine =
                  realloc (CmdLine, (strlen (FullPath) + 20) * sizeof (char));
               if (CmdLine != NULL)
               {
                  sprintf (CmdLine, "rd /S /Q \"%s\"", FullPath);
                  State = system (CmdLine); /* suppression du dossier */
               }
               else
               {
                  printf ("\nNo more memory available\n");
                  system ("pause");
                  exit (-1);
               }
            }
            if (State != 0)
            {
               fprintf (Log, "%s\n", FullPath);
               ToCheck++;
            }                   /* Si erreur pendant la supression ->log */
         RESULTS[i] = 1;
         }
         else
         {
            if (opendir (FullPath))
            {
               /* appelle la fonction sur les sous dossiers */
               RESULTS[i] = arbo (FullPath);
            }
            else
            {
               RESULTS[i] = 0;
            }
         }
      }                         /* fin de if (i>1) */
      i++;
   }                          /* Fin de la boucle qui traite les sous dossiers*/
 
   /* Cette boucle compte les 0 et les 1 renvoyés par
      l'appel de la fonction sur les sous dossier du
      dossier en cours */
   for (j = 2; j < i; j++)
   {
      if (j % STEP == 2)
      {
         FoldersNotZipped =
            realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));
      }
      if (RESULTS[j] == 0)
      {
         /* On stocke le chemin du sous dossier en cours dans FullPath */
         sprintf (FullPath, "%s\\%s", Path, SubFolderNames[j]);
         FoldersNotZipped[z] =
            malloc ((strlen (FullPath) + 1) * sizeof (char));
         if (FoldersNotZipped[z] != NULL)
         {
            /* On stocke les chemins associé a un 0 dans le
               tableau FoldersNotZipped
               On recupère le nom du ième sous dossier dans SubFolderNames */
            strcpy (FoldersNotZipped[z], FullPath);
         }
         else
         {
            printf ("\nNo more memory available\n");
            system ("pause");
            exit (-1);
         }
         z++;
      }
      else
      {
         u++;
      }
   }             /* fin de for (j=2;j<i;j++) */
/* Liberation des mémoires reservées */
  free (SubFolderNames);
  free (RESULTS);
 
/* En fonction des valeurs renvoyées par les sous dossiers,
   on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier */
   if (u == 0)
   {
      free (FoldersNotZipped);
      return 0;
   }
 
   for (i = 0; i < z; i++)
    {
     if (opendir (FoldersNotZipped[i]))
     {
        fprintf (Log, "%s\n", FoldersNotZipped[i]);
        ToCheck++;
     }
 
    }
    free (FoldersNotZipped);
    return 1;
 
}
 
 
/* fin de la fonction arbo */
 
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
 
int main (int argc, char *argv[])
{
   char CmdLine[256];
 
   clock_t temps_initial,       /* Temps initial en micro-secondes */
     temps_final;               /* Temps final en micro-secondes */
 
 
   double temps_cpu;             /* Temps total en micro-secondes */
 
   Log = fopen ("c:\\windows\\temp\\log.txt", "w+"); 
 
   if (Log == NULL)
   {                            /* Ouverture du  fichier de logs */
      fprintf (stderr, "The Log file could not be created"); 
      system ("pause");
      exit (-1);                
   }
   Copy_wzzip ();     /* crée une copie de wzzip (sans espace dans le chemin) */
 
   temps_initial = clock ();    /* Prends l'heure de départ */
 
   if (argc==2) 
      arbo (argv[1]);       /* appelle la fonction qui parcours l'arborescence*/
   else 
      printf("Please check arguments\n");
 
   fclose (Log);                /* Ferme le fichier de logs */
   temps_final = clock ();      /* Prends l'heure de fin */
 
 
   /* calcule le temps ecoulé et le convertit en secondes */
   temps_cpu = (temps_final - temps_initial) / CLOCKS_PER_SEC;
 
   printf ("\ntemps : %.2f\n", temps_cpu);
 
   system ("del c:\\windows\\temp\\wzzip.exe");
 
 
   sprintf (CmdLine,
          "Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\"");
 
   if (ToCheck!=0)
      system (CmdLine);
 
 
   system ("PAUSE");
 
   return 0;
}

Question subsidiaire, que penses-tu de cette façon de parcourir l'arborescence? Une fonction recursive etait-elle une solution bien adaptée, ou y en avait-il d'autres meilleures ?