allocation dynamique d'un tableau de chaîne de caractères

Version imprimable

Bonjour,
j'essaie de faire une allocation dynamique pour un tableau de char dont une dimension est connue (la taille des chaînes).
Voici le code qui pose problème...où est l'erreur ? J'ai dû mal lire la FAQ mais ce code plante :roll:
Code:

1 2 3 4 5 6 7 8 9 char texte[100]="Ceci est une chaine de caractères."; char * chaine=NULL; long n=2, i=0; chaine=malloc(100*n*sizeof(*chaine)); strcpy(chaine[i],texte ); printf("%s\n",chaine[i]); free(chaine);

Voici une méthode comment faire.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
        char texte[100]="Ceci est une chaine de caractères.";
        char *chaine=NULL;
 
        chaine=malloc(100*sizeof(chaine));
        if(chaine==NULL)
        {
                perror("erreur d'allocation");
                return 1;
        }
        strcpy(chaine,texte );
        printf("%s\n",chaine);
        free(chaine);
        return 0;
}

17/07/2007, 19h01
acryline

Oui mais c'est pour faire une allocation dynamique pour une chaîne de craractères. Mais j'aimerais faire une allocation pour un tableau de chaînes de caractères. :?
17/07/2007, 19h40
Espadrilles

ce n'est pas ce que tu disais dans ton premier post !

Tu cherches à faire quoi exactement ?

Si tu veux allouer dynamiquement un tableau de chaine de caractère alors tu dois commencer par allouer un tableau de pointeurs sur des char*, puis affecter à chaque pointeur alloué une nouvelle zone allouée dynamiquement sur des char.
(un malloc de 'n' char*, puis affecter chaque char* à un malloc de char).

Quoi qu'il en soit dans le code que tu as donné tu fais référence à (*chaine) avant qu'il ne soit alloué, tu demande donc ce qu'il y a à l'adresse NULL, donc ça plante.
17/07/2007, 20h24
gege2061

Bonjour,

une chaine de caractères n'est rien d'autre qu'un tableau de caractères, donc tu veux un tableaux de tableaux de caractères : Comment allouer dynamiquement un tableau à 2 dimensions ? ;)
17/07/2007, 20h24
acryline
Citation:

Envoyé par espadrille

ce n'est pas ce que tu disais dans ton premier post !

Citation:

Envoyé par acryline (premier post)

Bonjour,
j'essaie de faire une allocation dynamique pour un tableau de char dont une dimension est connue (la taille des chaînes).

;)
ça c'est exactement ce qui est dit dans la FAQ du C au sujet de l'allocation dynamique pour un
tableau à deux dimensions ...c'est donc ce que j'ai fait.
Code:

1 2 3 4 5 /* METHODE 2*/ char *tab; tab = malloc ( sizeof(*tab) * taille * taille2);
17/07/2007, 20h32
acryline

Citation:

Envoyé par gege2061

Bonjour,

une chaine de caractères n'est rien d'autre qu'un tableau de caractères, donc tu veux un tableaux de tableaux de caractères : Comment allouer dynamiquement un tableau à 2 dimensions ? ;)

Oui j'y suis déjà allée, mais ça ne marche pas. Je rencontre le problème dans l'application que je développe et dans le petit programme que j'ai fait pour tester l'allocation dynamique. (les quelques lignes que j'ai mis ici).

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
        char texte[100]="Ceci est une chaine de caractères.";
        char ** tab_chaine=NULL;
		int i;
 
        tab_chaine=(char**)malloc(100*sizeof(char *));
 
		for(i=0;i<100;i++)
			tab_chaine[i]=NULL;
 
        if(tab_chaine==NULL)
        {
                perror("erreur d'allocation");
                return 1;
        }
 
		i=0;
 
		while(tab_chaine[i]!=NULL && i<100)
			i++;
 
		if(i<100)
		{
                             tab_chaine[i]=(char*)malloc(100*sizeof(char ));
                             strcpy(tab_chaine[i],texte );
                             printf("%s\n",tab_chaine[i]);
		}
 
 
		for(i=0;i<100;i++)
			if(tab_chaine[i]!=NULL)
				free(tab_chaine[i]);
 
        return 0;
}

je crois que ça pourrai t aider

17/07/2007, 20h48
Emmanuel Delahaye

Citation:

Envoyé par acryline

Oui j'y suis déjà allée, mais ça ne marche pas. Je rencontre le problème dans l'application que je développe et dans le petit programme que j'ai fait pour tester l'allocation dynamique. (les quelques lignes que j'ai mis ici).

Mais si ça marche. Tu ne penses pas qu'on publierait du code incorrect ?

Montre le code qui ne fonctionne pas.
17/07/2007, 21h20
acryline

Il est dans mon premier post. Je ne voulais pas dire que cette solution ne fonctionne pas. Je voulais dire que l'application que j'en ai faite plante.
J'ai du faire une erreur, j'ai beau chercher, je ne la vois pas et j'aurais bien aimé que qq'un la trouve pour moi. :)
17/07/2007, 21h27
acryline

Citation:

Envoyé par pitikak

je crois que ça pourrai t aider

Merci pitikak... je regarde demain ton code et j'essaie de l'utiliser. Je donne des news. :)

C'est ça que tu veux faire ?

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int
main(void)
{
	char	texte[] = "Hello World !";
	char	**tab = NULL;
	int	err = 0;
	int	i = 0;
 
	/* tab contient 100 pointeurs vers des chaines de caractères */
	tab = malloc (100 * sizeof (char *));
 
	if (tab != NULL)
	{
		/* On initialise tous les pointeurs à NULL */
		/* J'ai un doute sur cette méthode... Qqun peut confirmer ? */
		memset (tab, 0, 100 * sizeof (char *));
 
		for (i = 0; i < 100; i++)
		{
			/* Chaque pointeur est alloué avec le strict nécessaire */
			/* Ne pas oublier le 0 de fin de chaine */
			tab[i] = malloc (strlen (texte) + 1);
 
			if (tab[i] != NULL)
			{
				strcpy (tab[i], texte);
				printf ("%d:\t%s\n", i, tab[i]);
			}
			else
			{
				fprintf (stderr, "Erreur d'allocation (%d) !\n", i);
				err = 1;
			}
		}
 
		/* On libère les chaines de caractères */
 		for (i = 0; i < 100; i++)
		{
			if (tab[i] != NULL)
				free (tab[i]);
		}
 
		/* On libère le tableau de pointeurs */
		if (tab != NULL)
			free (tab);
	}
	else
	{
		fprintf (stderr, "Erreur d'allocation !\n");
		err = 1;
	}
 
	return err;
}

Merci cette méthode fonctionne :D
Voilà j'édite pour vous mettre le code que j'ai écrit en prenant un peu ici et là, dans chacune des réponses. Il fonctionne chez moi.
Ah oui j'ai fait une erreur dans mon titre je n'aurais pas dû dire "tableau de char" mais" tableau de chaîne de caractères", j'ai été trop vite :(

[-mod- Corrigé.]

Voici mon 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
 
int main ()
{
 char chaine[100];
 char **tabChaine=NULL;
 /*n est un nombre variable de chaînes
 de caractères ici n=5 par exemple*/
 int i=0,n=5;
 
strcpy(chaine,"Une chaîne de caractères");
 
 /* Allocation de la 1er dimension */
 tabChaine=malloc(n*sizeof(*tabChaine));
 if (tabChaine!=NULL)
 {
     memset (tabChaine, 0, n * sizeof (char *));
    /*Allocation des n chaînes de caractères*/
     for (i=0;i<n;i++)
     {
       tabChaine[i]=malloc(sizeof(**tabChaine) * 100);
        if(tabChaine[i]!=NULL)
         {
             strcpy(tabChaine[i],chaine);
             printf("%s\n",tabChaine[i]);
         }
         else
         {
           perror("erreur d'allocation");
           return 1;
         }
     }
  //libération des chaines de caractères et du tableau de pointeurs
         for (i=0;i<n;i++)
         {
             if (tabChaine[i]!=NULL) free(tabChaine[i]);
         }
         if (tabChaine!=NULL) free(tabChaine);
 }
 else
 {
    perror("erreur d'allocation");
    return 1;
 }
return 0;
}

Citation:

Envoyé par acryline

Voici mon code :

Code incomplet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:3: warning: function declaration isn't a prototype
main.c: In function `main':
main.c:5: error: `NULL' undeclared (first use in this function)
main.c:5: error: (Each undeclared identifier is reported only once
main.c:5: error: for each function it appears in.)
main.c:10: warning: implicit declaration of function `strcpy'
main.c:13: warning: implicit declaration of function `malloc'
main.c:16: warning: implicit declaration of function `memset'
main.c:24: warning: implicit declaration of function `printf'
main.c:28: warning: implicit declaration of function `perror'
main.c:35: warning: implicit declaration of function `free'
Process terminated with status 1 (0 minutes, 1 seconds)
3 errors, 7 warnings

Ton code est correct. Voici une version plus significative :

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 <stdlib.h>
#include <string.h>
#include <stdio.h>
 
int main (void)
{
   char **tabChaine = NULL;
   /*n est un nombre variable de chaînes
      de caractères ici n=5 par exemple */
   int i = 0, n = 5;
 
   /* Allocation de la 1er dimension */
   tabChaine = malloc (n * sizeof (*tabChaine));
   if (tabChaine != NULL)
   {
      /* effacement du tableau (methode portable) */
      for (i = 0; i < n; i++)
      {
         tabChaine[i] = NULL;
      }
 
      /*Allocation des n chaînes de caractères */
      for (i = 0; i < n; i++)
      {
         tabChaine[i] = malloc (sizeof (**tabChaine) * 100);
         if (tabChaine[i] != NULL)
         {
            char s[32];
            sprintf (s, "Chaine %d", i);
            strcpy (tabChaine[i], s);
         }
         else
         {
            perror ("erreur d'allocation");
            return EXIT_FAILURE;
         }
      }
 
/* lecture du tableau */
      for (i = 0; i < n; i++)
      {
         if (tabChaine[i] != NULL)
            puts (tabChaine[i]);
      }
 
      //libération des chaines de caractères et du tableau de pointeurs
      for (i = 0; i < n; i++)
      {
         if (tabChaine[i] != NULL)
            free (tabChaine[i]);
      }
      if (tabChaine != NULL)
         free (tabChaine);
   }
   else
   {
      perror ("erreur d'allocation");
      return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
}

Mais il est en général de peu d'intérêt d'allouer une taille fixe. On préfère un mécanisme plus souple qui alloue le besouis exact pour la chaine de caractères. L'usage de strdup() est alors recommandé. Bien que non standard, cette fonction est POSIX.1 donc très portable. Elle est basée sur malloc(), donc la libération reste inchangée.

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
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
int main (void)
{
   char **tabChaine = NULL;
   /*n est un nombre variable de chaînes
      de caractères ici n=5 par exemple */
   int i = 0, n = 5;
 
   /* Allocation de la 1er dimension */
   tabChaine = malloc (n * sizeof (*tabChaine));
   if (tabChaine != NULL)
   {
      /* effacement du tableau (methode portable) */
      for (i = 0; i < n; i++)
      {
         tabChaine[i] = NULL;
      }
 
      /*Allocation des n chaînes de caractères */
      for (i = 0; i < n; i++)
      {
         char s[32];
         sprintf (s, "Chaine %d", i);
         tabChaine[i] = strdup (s);
 
         if (tabChaine[i] == NULL)
         {
            perror ("erreur d'allocation");
            return EXIT_FAILURE;
         }
      }
 
/* lecture du tableau */
      for (i = 0; i < n; i++)
      {
         if (tabChaine[i] != NULL)
            puts (tabChaine[i]);
      }
 
      //libération des chaines de caractères et du tableau de pointeurs
      for (i = 0; i < n; i++)
      {
         if (tabChaine[i] != NULL)
            free (tabChaine[i]);
      }
      if (tabChaine != NULL)
         free (tabChaine);
   }
   else
   {
      perror ("erreur d'allocation");
      return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
}