Je galere avec l'assignation dynamique de mémoire

**alexinho** · 10/04/2007, 18h55

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** · 10/04/2007, 19h49

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** · 10/04/2007, 19h55

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** · 10/04/2007, 19h57

[
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** · 10/04/2007, 20h14

Oui, on ne sait pas ce qu'est FULLPATH

**alexinho** · 11/04/2007, 17h22

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** · 11/04/2007, 17h45

Envoyé par alexinho

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** · 11/04/2007, 18h57

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

Je galere avec l'assignation dynamique de mémoire

C

Vue hybride

Discussions similaires

Partager

Partager