Discussion :

[odsen.s]

Bonjour à tous,

J'ai essayé de faire un programme permettant une saisie de caractère "illimitée" sur l'entrée standard.
Le comportement me paraît bon, mais je tenais quand même à vous montrer le code pour voir si je n'avais pas commis une bourde (je n'ai pas l'habitude d'utiliser realloc()).

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
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   size_t size = 2;
   char *s = malloc (size);
 
   if(s != NULL)
   {
      int c;
      int fin = 0;
      size_t i = 0;
      while((c = getchar()) != '\n' && c != EOF && !fin)
      {
         if(i >= size-1)
         {
            size *= 1.5;
            char *p_tmp = realloc(s, size);
 
            if(p_tmp != NULL)
            {
               s = p_tmp;
               s[i++] = c;
            }
            else
            {
               fin = 1;
            }
         }
         else
         {
            s[i++] = c;
         }
      }
 
      s[i] = '\0';
      printf("saisie : %s\n", s);
   }
   else
   {
      printf("erreur d'allocation memoire\n");
   }
 
   return 0;
}

Voyez-vous des corrections à effectuer ?
Par avance, merci.

[Zavonen]

Je remarque que la taille du buffer croit de manière exponentielle:

Code :

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

1
2
 size *= 1.5;
            char *p_tmp = realloc(s, size);

Ne vaudrait-il pas mieux quelque chose de plus progressif (par exemple une croissance arithmétique) ?

[odsen.s]

Je remarque que la taille du buffer croit de manière exponentielle:

Code :

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

1
2
 size *= 1.5;
            char *p_tmp = realloc(s, size);

Ne vaudrait-il pas mieux quelque chose de plus progressif (par exemple une croissance arithmétique) ?

D'après ce que j'ai lu ici et là, il vaut mieux multiplier par un nombre inférieur au nombre d'or. On peut donc utiliser 1.5 comme facteur de multiplication. Je ne me rappelle plus bien la raison, mais c'est préférable à ajouter de l'espace pour chaque caractère.

[Zavonen]

Vous commencez à deux et vous multipliez par 1.5 à chaque fois.
Voici donc les tailles successives allouées ou réallouées:
2 3 4 6 9 13 19 28 32 48 64
96 128 192 288 bon...
Si vous avez besoin de 300 caractères vous en mobiliserez 432 soit 132 de trop, et le pourcentage ne fera que croitre avec la longueur de la chaine.
En fait il faudrait connaitre a priori:
la longueur moyenne des chaines que vous entrez
la taille minimale
la taille maximale
pour décider de la bonne stratégie.

[odsen.s]

En fait il faudrait connaitre a priori:
la longueur moyenne des chaines que vous entrez
la taille minimale
la taille maximale
pour décider de la bonne stratégie.

Justement, le but du programme est de pouvoir saisir entièrement une chaîne de longueur inconnue, donc pas de taille minimale ou maximale.
Après, s'il y a des moyens de réallouer de l'espace mémoire avec moins de "pertes", et en limitant le nombre de réallocations comme ici, je suis preneur.

[Zavonen]

Je me suis peut être mal fait comprendre:
Dans tous les cas on proposera un système qui ne se bloque pas, mais la discussion porte sur mode de croissance du buffer.
Moi je proposerais une croissance arithmétique du genre:

Code :

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

1
2
size += 50;
            char *p_tmp = realloc(s, size);

qui assurerait que l'espace maximal perdu reste inférieur à 50 octets.
NB: realloc est très rapide, imperceptible pendant une opération de saisie

[Emmanuel Delahaye]

J'ai essayé de faire un programme permettant une saisie de caractère "illimitée" sur l'entrée standard.
<...>
Voyez-vous des corrections à effectuer ?
Par avance, merci.

Première chose à faire : une fonction :

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
 
#include <stdio.h>
#include <stdlib.h>
 
char *get_line (void)
{
   size_t size = 2;
   char *s = malloc (size);
 
   if (s != NULL)
   {
      int c;
      int fin = 0;
      size_t i = 0;
      while ((c = getchar ()) != '\n' && c != EOF && !fin)
      {
         if (i >= size - 1)
         {
            size *= 1.5;
            char *p_tmp = realloc (s, size);
 
            if (p_tmp != NULL)
            {
               s = p_tmp;
               s[i++] = c;
            }
            else
            {
               fin = 1;
            }
         }
         else
         {
            s[i++] = c;
         }
      }
 
      s[i] = '\0';
   }
   return s;
}
 
int main (void)
{
   char *s = get_line ();
   if (s != NULL)
   {
      printf ("s='%s'\n", s);
      free (s);
   }
   else
   {
      printf ("erreur d'allocation memoire\n");
   }
   return 0;
}

Malgré une instrumentation poussée (au prix d'une légère modification)

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
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
 
#define get_line() fget_line (stdin)
 
char *fget_line (FILE * fp)
{
   size_t size = 2;
   char *s = malloc (size);
 
   if (s != NULL)
   {
      int c;
      int fin = 0;
      size_t i = 0;
 
      memset (s, '?', size);
 
      while ((c = fgetc (fp)) != '\n' && c != EOF && !fin)
      {
         if (i >= size - 1)
         {
            char *p_tmp = realloc (s, size * 1.5);
 
            if (p_tmp != NULL)
            {
               /* ne pas factoriser. Calculs entiers... */
               memset (p_tmp + size, '?', (size * 1.5) - size);
               size *= 1.5;
               s = p_tmp;
               assert (i < size - 1);
/* -ed-
               s[i++] = c;
   a eviter
*/
               s[i] = c;
               i++;
            }
            else
            {
               fin = 1;
            }
         }
         else
         {
            assert (i < size - 1);
            s[i] = c;
            i++;
         }
      }
 
      assert (i < size);
      s[i] = '\0';
   }
   return s;
}
 
int main (void)
{
   int fin = 0;
   while (!fin)
   {
      char *s = get_line ();
      if (s != NULL)
      {
         printf ("s='%s'\n", s);
         fin = *s == 0;
         free (s);
 
      }
      else
      {
         printf ("erreur d'allocation memoire\n");
         fin = 1;
      }
   }
   return 0;
}

Je n'ai pas pu mettre ce code en défaut.