allocation dynamique de chaîne

**gauguin** · 17/02/2007, 00h28

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 :

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

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' */

**Emmanuel Delahaye** · 17/02/2007, 00h52

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.

**Thierry Chappuis** · 17/02/2007, 00h56

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

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

**souviron34** · 17/02/2007, 00h58

Envoyé par Emmanuel Delahaye

Oui.

**David.Schris** · 17/02/2007, 02h35

Envoyé par mujigka

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

Code :

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

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

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

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" ?

**Emmanuel Delahaye** · 17/02/2007, 03h35

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 ?

**Emmanuel Delahaye** · 17/02/2007, 03h50

Envoyé par mujigka

<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
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()

**David.Schris** · 17/02/2007, 03h54

Envoyé par Emmanuel Delahaye

Pourquoi ?

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

Code :

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

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

à

Code :

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

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 :

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

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

**Emmanuel Delahaye** · 17/02/2007, 04h02

Envoyé par David.Schris

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

Code :

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

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 :

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

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 :

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

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

**David.Schris** · 17/02/2007, 04h04

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

**Thierry Chappuis** · 17/02/2007, 08h19

Envoyé par Emmanuel Delahaye

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