allocation dynamique de chaîne

Version imprimable

17/02/2007, 00h28
gauguin

allocation dynamique de chaîne
Salut,

Je suis sur les chaînes de caractères et j'ai une question.
est-il possible de réserver juste la taille nécessaire pour une chaîne de caractères de façon dynamique, c'est à dire que la taille du tableau ou du pointeur vers une chaîne se calcule au moment où l'utilisateur tape un retour chariot ?

je précise, mais ce code est faux, c'est juste pour montrer ce à quoi je pense;
Code:

1 2 3 4 5 6 7 int i=0; int x=0; char *s; gets(s); for(i=0; *(s+i)!=NULL; i++) x++; /*je compte les caractères*/ s[x+1]; /*j'alloue pile la taille necessaire et le +1 pour laisser la place au '\0' */
17/02/2007, 00h52
Emmanuel Delahaye

Citation:

Envoyé par gauguin

est-il possible de réserver juste la taille nécessaire pour une chaîne de caractères de façon dynamique, c'est à dire que la taille du tableau ou du pointeur vers une chaîne se calcule au moment où l'utilisateur tape un retour chariot ?

Oui.

Règle n°1: ne jamais utiliser la fonction gets(), fgets() est là pour la remplacer.

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(void)
{
    /* Tu définis un tampon suffisamment grand pour tes besoins */
    char s_buffer[100];
    char *s_ma_chaine = NULL;
    size_t taille_chaine = 0;
 
    /* On invite l'utilisateur */
    printf("Introduisez une chaîne de caractères: ");
    fflush(stdout);
 
    fgets(s_buffer, sizeof s_buffer, stdin);
    taille_chaine = strlen(s_buffer);
 
    /* On alloue la mémoire nécessaire pour contenir la chaine */
    s_ma_chaine = malloc((taille_chaine + 1) * sizeof *s_ma_chaine);
    if (s_ma_chaine != NULL)
    {
        /* On copie la chaine dans s_ma_chaine */
        *s_ma_chaine = 0;
        strncat(s_ma_chaine, s_buffer, taille_chaine);
 
        /* On fait des traitements sur la chaine */
        printf("Voici la chaine entrée par l'utilisateur: %s\n", s_ma_chaine);
 
        /* On libère l'espace alloué pour la chaine */
        free((void *) s_ma_chaine), s_ma_chaine = NULL;
    }
    else
    {
        fprintf(stderr, "L'allocation a échoué!\n");
        exit(EXIT_FAILURE);
    }
 
    return EXIT_SUCCESS;
}

Thierry

17/02/2007, 00h58
souviron34

Citation:

Envoyé par Emmanuel Delahaye

Oui.

:king:

Citation:
Envoyé par mujigka
Règle n°1: ne jamais utiliser la fonction gets(), fgets() est là pour la remplacer.
Code:

1 2 3 4 5 6 7 8 9 10 11 /* [...] */ char s_buffer[100]; /* [...] */ /* On copie la chaine dans s_ma_chaine */ *s_ma_chaine = 0; strncat(s_ma_chaine, s_buffer, taille_chaine); /* [...] */
Un #define pour la taille ne ferait pas de mal.

Et puis attention à ça :
Code:

1 2 3 4 5 6 $ ./mu Introduisez une chaîne de caractères: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbb Voici la chaine entrée par l'utilisateur: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Enfin, si tu peux utiliser strncat(), pourquoi ne pas utiliser strncpy() pour faire, je te cite, une "copie" ?

17/02/2007, 03h35
Emmanuel Delahaye

Citation:

Envoyé par David.Schris

Un #define pour la taille ne ferait pas de mal.

Pourquoi ? L'important est que la définition soit unique et centralisée. Quel meilleur endroit que la définition du tableau ?

Citation:

Envoyé par mujigka

<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
60
61
62
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static int fclean(char *s, FILE *fp)
{
   int err;
   char *p = strchr (s, '\n');
   if (p != NULL)
   {
      *p = 0;
      err = 0;
   }
   else
   {
      int c;
      while ((c = fgetc (fp)) != '\n' && c != EOF)
      {
      }
      err = 1;
   }
   return err;
}
 
int main(void)
{
   int ret = EXIT_SUCCESS;
   /* Tu définis un tampon d'une taille raisonnable */
   char s_buffer[100];
 
   /* On invite l'utilisateur */
   printf("Introduisez une chaine de caracteres: ");
   fflush(stdout);
 
   fgets(s_buffer, sizeof s_buffer, stdin);
   if (fclean (s_buffer, stdin) == 0)
   {
      /* On alloue la mémoire nécessaire pour contenir la chaine */
      char * s_ma_chaine = strdup (s_buffer);
      if (s_ma_chaine != NULL)
      {
         /* On fait des traitements sur la chaine */
         printf("Voici la chaine entree par l'utilisateur: %s\n", s_ma_chaine);
 
         /* On libère l'espace alloué pour la chaine */
         free(s_ma_chaine), s_ma_chaine = NULL;
      }
      else
      {
         fprintf(stderr, "L'allocation a échoue!\n");
         ret = EXIT_FAILURE;
      }
   }
   else
   {
      fprintf(stderr, "La saisie est tronquee!\n");
      ret = EXIT_FAILURE;
   }
       getchar();
   return ret;
}

strdup() est POSIX.1 et facile à reproduire...
Il y a d'autres possibilités plus souples.

http://emmanuel-delahaye.developpez.com/clib.htm
Module IO : get_line()

17/02/2007, 03h54
David.Schris
Citation:

Envoyé par Emmanuel Delahaye

Pourquoi ?

Pour éviter de prendre une mauvaise habitude.
On a vite fait de passer de

Code:

char tab[10]; /* un tableau dont je pourrai vouloir modifier la taille plus tard dans la vie du projet */

à
Code:

1 2 3 4 5 6 char tab[10]; unsigned int i; /* insérer du code ici */ for(i=0; i<10; i++) { /* faire quelque-chose avec tab[i] */ }
puis à
Code:

1 2 3 4 5 6 char tab[8]; /* finalement, c'était 8 que je voulais mettre */ unsigned int i; /* insérer du code ici */ for(i=0; i<10; i++) { /* faire quelque-chose avec tab[i] */ }
Avec la " #define attitude ", ce genre d'erreur n'arrive plus et la définition peut être unique et centralisée quand "attitude" rime avec "habitude".

Cordialement,
DS.

PS : merci de (j'anticipe) ne pas me faire dire ce que je n'ai pas dit...Je n'ai pas dit qu'il fallait mettre des #define pour toutes les tailles de tableau ni qu'on ne pouvait pas utiliser sizeof dans cet exemple...

Citation:

Envoyé par David.Schris

Pour éviter de prendre une mauvaise habitude.
On a vite fait de passer de

Code:

char tab[10]; /* un tableau dont je pourrai vouloir modifier la taille plus tard dans la vie du projet */

à

C'est pour ça qu'il faut écrire du code auto démerdant...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 /* dans un include general genre 'mytools.h' */ #define NELEM(a) (sizeof(a)/sizeof*(a)) { char tab[10]; unsigned int i; /* insérer du code ici */ for (i = 0; i < NELEM (tab); i++) { /* faire quelque-chose avec tab[i] */ } }
puis à
Code:

1 2 3 4 5 6 7 8 9 { char tab[8]; /* finalement, c'était 8 que je voulais mettre */ unsigned int i; /* insérer du code ici */ for (i = 0; i < NELEM (tab); i++) { /* faire quelque-chose avec tab[i] */ }
Faut laisser le code se corriger tout seul...

17/02/2007, 04h04
David.Schris

Citation:

Envoyé par David.Schris

[...] Je n'ai pas dit [...] qu'on ne pouvait pas utiliser sizeof dans cet exemple...

Comme quoi...Je commence à te connaître...

Citation:
Envoyé par Emmanuel Delahaye
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 60 61 62 #include <stdio.h> #include <stdlib.h> #include <string.h> static int fclean(char *s, FILE *fp) { int err; char *p = strchr (s, '\n'); if (p != NULL) { *p = 0; err = 0; } else { int c; while ((c = fgetc (fp)) != '\n' && c != EOF) { } err = 1; } return err; } int main(void) { int ret = EXIT_SUCCESS; /* Tu définis un tampon d'une taille raisonnable */ char s_buffer[100]; /* On invite l'utilisateur */ printf("Introduisez une chaine de caracteres: "); fflush(stdout); fgets(s_buffer, sizeof s_buffer, stdin); if (fclean (s_buffer, stdin) == 0) { /* On alloue la mémoire nécessaire pour contenir la chaine */ char * s_ma_chaine = strdup (s_buffer); if (s_ma_chaine != NULL) { /* On fait des traitements sur la chaine */ printf("Voici la chaine entree par l'utilisateur: %s\n", s_ma_chaine); /* On libère l'espace alloué pour la chaine */ free(s_ma_chaine), s_ma_chaine = NULL; } else { fprintf(stderr, "L'allocation a échoue!\n"); ret = EXIT_FAILURE; } } else { fprintf(stderr, "La saisie est tronquee!\n"); ret = EXIT_FAILURE; } getchar(); return ret; }
strdup() est POSIX.1 et facile à reproduire...
Il y a d'autres possibilités plus souples.

http://emmanuel-delahaye.developpez.com/clib.htm
Module IO : get_line()
J'ai encore oublié strdup(), c'est vrai, honte sur moi! get_line() est la fonction que j'utilise habituellement pour cela (merci Emmanuel pour ta bibliothèque clib, extrêment utile). Sur le forum, pour des questions comme celle-là, j'essaie autant que possible de ne pas proposer de solutions impliquant une bibliothèque tièrce.

En ce qui concerne la question de la #define attitude. J'ai ici un buffer unique. Si je dois écrire une boucle pour afin d'itérer sur le tampon, j'utiliserai plutôt du code auto-démerdant (pour reprendre la terminologie introduite par Emmanuel).

Thierry

17/02/2007, 10h08
gauguin

salut,

merci pour vos réponses.
Il y a pas mal de connaissances que je n'ai pas encore. ( l'art est long mais le temps est court...:D )
17/02/2007, 10h38
Emmanuel Delahaye

Citation:

Envoyé par mujigka

Jj'utiliserai plutôt du code auto-démerdant (pour reprendre la terminologie introduite par Emmanuel).

C'était l'expression favorite de mon prof d'électronique...