[File] récupérer le contenu d'un fichier

Version imprimable

Voir 40 message(s) de cette discussion en une page

J'ai bien noté le

Citation:

malloc peut échouer (comme fopen)

Comment tester le retour du malloc ?

ainsi ?
Code:

1 2 3 4 5 content = malloc(size+1); if(content !=NULL) { .. }
Pour les questions concernant le fichier à lire, je ne connais pas la taille ni le contenu à l'avance.

Il a été aussi question de libérer mon content une fois fini.. mais content est une variable de retour de fonction...
Code:

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 char * _ReadFile(const char *filename) { FILE* fSrc; char buffer[512]; int NbLu; char * content=NULL; long size = 0; fSrc=fopen(filename, "r"); if(fSrc != NULL) { fseek(fSrc, 0, SEEK_END); // aller en fin size = ftell(fSrc); // lire la taille fseek(fSrc, 0, SEEK_SET); // rétablir la position // alloc content = malloc(size+1); while((NbLu=fread(buffer, 1, 512, fSrc)) != 0) { strcat(content, buffer); } fclose(fSrc); } content[size+1] = '\0'; return content; }
Dans ce cas, la mémoire ne se libère t-elle pas d'elle même ?

19/06/2006, 10h17
Pragmateek
Code:

1 2 3 4 5 content = malloc(size+1); if(content !=NULL) { .. }
Plutôt:
Code:

1 2 3 4 5 content = malloc(size+1); if(content ==NULL) { /*gestion de l'erreur*/ }
Citation:

Dans ce cas, la mémoire ne se libère t-elle pas d'elle même ?

Non il faudra faire un "free(content);" quand "content" devient inutile.

Citation:
Envoyé par kendras
Comment tester le retour du malloc ? ainsi ?
Code:

1 2 3 4 5 content = malloc(size+1); if(content !=NULL) { .. }
Oui.

http://emmanuel-delahaye.developpez....tes.htm#malloc

Citation:

Il a été aussi question de libérer mon content une fois fini.. mais content est une variable de retour de fonction...

Code:

char * _ReadFile(const char *filename)

:!: Identificateur réservé.

http://emmanuel-delahaye.developpez....htm#id_reserve
Citation:
Code:

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 { FILE* fSrc; char buffer[512]; int NbLu; char * content=NULL; long size = 0; fSrc=fopen(filename, "r"); if(fSrc != NULL) { fseek(fSrc, 0, SEEK_END); // aller en fin size = ftell(fSrc); // lire la taille fseek(fSrc, 0, SEEK_SET); // rétablir la position // alloc content = malloc(size+1); while((NbLu=fread(buffer, 1, 512, fSrc)) != 0) { strcat(content, buffer); } fclose(fSrc); } content[size+1] = '\0'; return content; }
Dans ce cas, la mémoire ne se libère t-elle pas d'elle même ?
Non.
Tout ce qui a été alloué doit être libéré.
Ta méthode de lecture est horrible.
Tu utilises strcat() sur des tableaux de char qui ne sont pas forcément des chaines valides. Sans compter que c'est totalement inefficace.

Je ferais comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <...> content = malloc (size + 1); if (content != NULL) { OK = 0; if (fread (buffer, 1, size, fSrc) == size) { buffer[size] = 0; OK = 1; } /* traitement de buffer (si OK) */ free (buffer), buffer = NULL; } fclose(fSrc), fSrc = NULL; <...>

19/06/2006, 10h36
kendras

A noter que strcat(content, buffer); ne fonctionne pas lorsque je fais content = malloc(size+1);

J'ai un Segmentation Fault (core dumped)

Mon fichier de test contient 578 caractères (espaces compris)

size = ftell(fSrc);
size donne 606

Après recherche, pour que mon strcat fonctionne, il faudrait que je fasse un malloc à 1017 au moins
content = malloc(1017);
Pourquoi ?
19/06/2006, 10h40
kendras

Ok!
Oublions mon message précédent suite à la réponse Emmanuel .

Merci, je vais tester ça de suite ;)

Ok, donc cela me donne ça :

Code:

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
char * pReadFile(const char *filename)
{
	FILE* fSrc;
	char buffer[10000];
	int NbLu;
	char * content=NULL;
	long unsigned size = 0;
	int OK = 0;
	fSrc=fopen(filename, "r");
 
	if(fSrc != NULL)
	{
		fseek(fSrc, 0, SEEK_END);       // aller en fin 
		size = ftell(fSrc);             // lire la taille 
		fseek(fSrc, 0, SEEK_SET); 			// rétablir la position 
 
		if (fread (buffer, 1, size, fSrc) == size)
		{
			buffer[size] = 0;
			OK = 1;
		}
 
		/* traitement de buffer (si OK) */
		if(OK==1)
		{
			content = malloc(sizeof(buffer) + 1);
			strcpy(content, (char*)buffer);
		}
 
		free (buffer);
 
		fclose(fSrc), fSrc = NULL;
	}
	return content;
 
}

C'est surement plus joli et plus propre ainsi.
Merci pour les corrections de syntaxe que je ne maitrise pas forcément (voir pas du tout).

Comment puis-je libérer content ?

19/06/2006, 11h11
gnto
Citation:

Envoyé par kendras

Comment puis-je libérer content ?
Code:

1 2 3 4 5 char * pVar; pVar = pReadFile("toto.txt"); free(pVar);
19/06/2006, 11h21
kendras

Ok.

Concernant cette libération de mémoire, ceci est uniquement valable lorsque l'on alloue de la mémoire avec malloc ?

J'ai par exemple crée une structure "transmission".
Est-il necessaire/possible de nettoyer les variables de type "transmission" ?
19/06/2006, 11h25
gnto

ben la faut aller voir des tutos ou ouvrir un bouquin sur le C sur les déclarations statiques et dynamiques
19/06/2006, 11h35
kendras

OK, merci pour se renvoie vers la documentation ;-)

Citation:

Envoyé par kendras

Ok, donc cela me donne ça :

Code:

1
2
3
4
5
6
char * pReadFile(const char *filename)
{
	char buffer[10000];
<...>
		free (buffer);
}

8O 8O 8O Je n'ai jamais dit qu'il fallait que buffer soit un tableau de taille fixe. au contraire :

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
 
static char *pReadFile(const char *filename)
{
   char *buffer = NULL;
   FILE *fSrc = fopen(filename, "r");
 
   if (fSrc != NULL)
   {
      fseek(fSrc, 0, SEEK_END);       // aller en fin
      {
         unsigned long size = ftell(fSrc);             // lire la taille
         /* ne pas depasser ce que peut contenir un size_t ... */
         if (size < (size_t) - 1)
         {
            rewind(fSrc);    // rétablir la position
 
            /* allouer le bloc + une place pour le 0 */
            buffer = malloc(size + 1);
            if (buffer != NULL)
            {
               int ok = 0;
               /* lire le ficher (in one gulp...) */
               if (fread (buffer, 1, size, fSrc) == size)
               {
                  /* ajouter le 0 final */
                  buffer[size] = 0;
                  ok = 1;
               }
               if (!ok)
               {
                  /* en cas d'erreur de lecture, liberer le bloc ... */
                  free (buffer), buffer = NULL;
               }
            }
         }
      }
      fclose(fSrc), fSrc = NULL;
   }
   return buffer;
}
 
int main()
{
   char * s = pReadFile("corbeau.txt");
 
   if (s != NULL)
   {
      puts (s);
      free (s), s = NULL;
   }
 
   return 0;
}

19/06/2006, 12h33
kendras

Oui, merci.
J'avais corrigé entre temps en me rendant compte que c'était débile de mettre du statique :oops:

Voir 40 message(s) de cette discussion en une page