reallocation de buffer de lecture de fichier

Version imprimable

Bonjour

Ça fait maintenant un bon bout de temps que je ne fréquente plus le forum C.
Je viens de recevoir un mp au sujet d'une contribution que j'avais écrite sur la réallocation du buffer de saisie à la volée.
Ne l'ayant plus et ne la trouvant pas sur le site, j'ai tenté de la réécrire et je viens la poster ici pour deux raisons :

savoir si elle est correcte
que le po ne s'approprie pas la réponse et que tout le monde puise la partager (si elle est correcte bien entendu)

Voici le code :
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 57 58 59 // fonction de lecture de lignes d'un fichier ouver en mode texte int lecture(FILE *f) { // longueur initiale du buffer de lecture // on peut choisir une autre valeur bien entendu ! size_t len = 10; size_t old_len = len; // le meilleur facteur d'accroissement de longueur est le nombre d'or ! // le nombre d'or = 1,61803399 double incr = 1.62; char *ptr; int flag = 0 ; // 0 si la lecture a été complète, 1 sinon // initialisation du buffer de saisie ptr = malloc(len); // toujours tester le retour du malloc if (ptr == NULL) { fprintf(stderr, "Pb alloc memoire \n"); return 0; } while(fgets(ptr + (flag > 0) * old_len - flag , len - (flag > 0) * old_len, f) != NULL) { // on teste si la saisie est complète char *p = strchr(ptr, '\n') ; if (p == NULL) { // saisie incomplète char *tmp ; old_len = len; len = (size_t) (incr * len); tmp = realloc(ptr, len); if (tmp == NULL) { // l'allocation a echoue, on ne peut rien faire fprintf(stderr, "Pb alloc memoire \n"); return 0; } else ptr = tmp; flag ++; } else { *p = 0; flag = 0; // ici on peut travaille sur la saisie complète // simple affichage puts(ptr); } } free(ptr); return 1; }
J'avoue que j'ai un problème sur le fgets, je ne sais pas bien expliquer pourquoi il faut écrire (ptr + (flag > 0) * old_len - flag , si on passe plusieurs fois dans une lecture incomplète, flag comptant le nombre de lecture incomplètes consécutives.

merci de vos remarques éventuelles.

04/04/2011, 19h16
diogene

En fait, il s'agit certainement d'une erreur sur la taille du buffer disponible qui a été compensée par le -flag dans ptr + (flag > 0) * old_len - flag

- Au début d'une nouvelle ligne, le fgets est équivalent à

Code:

fgets(ptr,oldlen, f)

ce qui est correct.

- Si cette ligne est incomplète, on a un '\0' en position ptr+oldlen-1.
le fgets() devient (avec flag=1)

Code:

fgets(ptr + old_len - 1, len - old_len, f)

Le -1 est destiné à se positionner sur le dernier élément du buffer précédent pour écraser le '\0' qu'il contient.
Le buffer disponible est alors de taille len - old_len+1 (à cause de la récupération de la place du '\0') mais on ne demande bizarrement que len - old_len caractères

- Si la ligne est à nouveau incomplète, le '\0' va alors se trouver en ptr + old_len - 1 + len - old_len -1 = ptr+len-2. Ce qui explique le fgets suivant (avec flag =2)

Code:

fgets(ptr + old_len - 2, len - old_len, f)

Avec toujours cette étrangeté sur la longueur disponible dans le buffer qui en réalité est maintenant len - old_len+2

Ceci étant, j'avoue que je n'aime pas ce genre d'expressions (flag > 0) * old_len qui mélange des type booléens et arithmétiques : pour moi flag>0 vaut vrai ou faux et je ne veux pas avoir à considérer que vrai est 1 et faux 0. Je préfère ptr - flag+ (flag > 0) ? old_len : 0

Merci de ta réponse, j'étais focalisé sur le positionnement du début de lecture et j'ai oublié en cours la longueur à lire qui ne me paraissait pas cohérente.
Merci de tes remarques, je corrige :

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
57
58
59
// fonction de lecture de lignes d'un fichier ouver en mode texte
int lecture(FILE *f)
{
	// longueur initiale du buffer de lecture
	// on peut choisir une autre valeur bien entendu !
	size_t len = 10;
	size_t old_len = len;
	// le meilleur facteur d'accroissement de longueur est le nombre d'or !
	// le nombre d'or = 1,61803399
	double incr = 1.62;
	char *ptr;
	int flag = 0 ; // 0 si la lecture a été complète, 1 sinon
 
	// initialisation du buffer de saisie
	ptr = malloc(len);
 
	// toujours tester le retour du malloc
	if (ptr == NULL)
	{
		fprintf(stderr, "Pb alloc memoire \n");
		return 0;
	}
 
	while(fgets(ptr + ((flag > 0) ? old_len : 0) -flag, len - ((flag > 0) ? old_len : 0) + flag, f) != NULL)
	{
		// on teste si la saisie est complète
		char *p = strchr(ptr, '\n') ;
		if (p == NULL)
		{
			// saisie incomplète
			char *tmp ;
 
			old_len = len;
			len = (size_t) (incr * len);
 
			tmp = realloc(ptr, len);
			if (tmp == NULL)
			{
				// l'allocation a echoue, on ne peut rien faire
				fprintf(stderr, "Pb alloc memoire \n");
				return 0;
			}
			else
				ptr = tmp;
			flag ++;
		}
		else
		{
			*p = 0;
			flag = 0;
 
			// ici on peut travaille sur la saisie complète
			// simple affichage 
 		        puts(ptr);
		}
	}
	free(ptr);
	return 1;
}

Toute petite erreur, lorsque flag = 0, c'est équivalent à

Code:

fgets(ptr, len, f)

Le code est incorrect à cause d'une erreur sur l'adresse où on écrit.

- Pouquoi ne pas utiliser
Code:

1 2 while(fgets(ptr + ((flag > 0) ? old_len-1 : 0 ), len - ((flag > 0) ? old_len-1: 0), f) != NULL) ....
qui corrige l'erreur sur la place disponible dans le buffer ?
Ou même carrément supprimer flag en utilisant old_len initialisé à 1 avant chaque ligne

- Le strchr() peut ne se faire que sur la partie nouvellement lue. Il est inutile de faire analyser la partie déjà remplie du buffer.

- Avec ces remarques :
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 int lecture(FILE *f) { // longueur initiale du buffer de lecture // on peut choisir une autre valeur bien entendu ! size_t len = 4; // le meilleur facteur d'accroissement de longueur est le nombre d'or ! // le nombre d'or = 1,61803399 double const incr = 1.62; char *ptr; size_t old_len; // initialisation du buffer de saisie if(len<2)len = 2; // len doit être > 1 ptr = malloc(len); if (ptr == NULL) // toujours tester le retour du malloc { fprintf(stderr, "Pb alloc memoire \n"); return 0; } old_len = 1; while(fgets(ptr+old_len-1, len-old_len+1, f) != NULL) { char *p = strchr(ptr+old_len-1, '\n') ; // on teste si la saisie est complète if (p == NULL) // saisie incomplète { char *tmp ; old_len = len; len = incr * len; tmp = realloc(ptr, len); if (tmp == NULL) { // l'allocation a echoue, on ne peut rien faire fprintf(stderr, "Pb alloc memoire \n"); return 0; } else ptr = tmp; } else { *p = 0; old_len = 1; // ici on peut travaille sur la saisie complète // simple affichage puts(ptr); } } free(ptr); return 1; }
- La valeur de len n'est pas réinitialisé à chaque début de ligne, donc on repart avec l'allocation obtenue précédemment. Ce n'est pas en soi un inconvénient, mais si on modifie la fonction pour qu'elle renvoie la ligne lue (au lieu de prévoir un traitement interne à la fonction), cela deviendra ennuyeux.

05/04/2011, 15h15
Trap D

Bonjour

Il faut que je me remette sérieusement au C, je n'arrive même plus à tester correctement :oops:

Pas bete du tout cette histoire de old_len initialisée à 1 ça simplifie beaucoup le code. :ccool:

La seconde remarque sur le strchr est judicieuse aussi.

Merci, je pense qu'on peut mettre :resolu: à la discussion !