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

**acryline** · 17/07/2007, 19h15

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

Code :

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

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

**je®ome** · 17/07/2007, 19h24

Voici une méthode comment faire.

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

**acryline** · 17/07/2007, 20h01

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.

**Espadrilles** · 17/07/2007, 20h40

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.

**gege2061** · 17/07/2007, 21h24

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 ?

**acryline** · 17/07/2007, 21h24

Envoyé par espadrille

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

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 :

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

1
2
3
4
5
 
/* METHODE 2*/
char *tab;
 
tab = malloc ( sizeof(*tab)  *  taille * taille2);

**acryline** · 17/07/2007, 21h32

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

**pitikak** · 17/07/2007, 21h42

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

**Emmanuel Delahaye** · 17/07/2007, 21h48

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.

**acryline** · 17/07/2007, 22h20

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.

**acryline** · 17/07/2007, 22h27

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.

**Freed0** · 17/07/2007, 22h28

C'est ça que tu veux faire ?

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

**acryline** · 18/07/2007, 08h02

Merci cette méthode fonctionne

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 :

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
 
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;
}

**Emmanuel Delahaye** · 18/07/2007, 10h01

Envoyé par acryline

Voici mon code :

Code incomplet :

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

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

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

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

C

Discussions similaires

Partager

Partager