reallocation de buffer de lecture de fichier

**Trap D** · 04/04/2011, 18h23

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 :

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
// 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.

**diogene** · 04/04/2011, 19h16

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 :

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

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 :

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

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 :

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

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

**Trap D** · 04/04/2011, 20h20

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 :

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
// 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 :

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

fgets(ptr, len, f)

**diogene** · 04/04/2011, 23h55

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

- Pouquoi ne pas utiliser

Code :

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

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 :

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
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.