Allocation dynamique de tableau à 2 dimensions

Version imprimable

Bonjour,

J'ai besoin d'allouer dynamiquement un tableau à deux dimensions.
J'ai donc suivi la méthode de la FAQ :

Code:

1
2
3
4
5
6
7
8
9
10
/* METHODE 1 */
char **tab;
 
/* Allocation de la 1er dimension */
tab = malloc ( sizeof(*tab)  *  taille);
/* Allocation des tableaux */
for (i=0; i<taille; i++)
{
   tab[i] = malloc ( sizeof(**tab) * taille2);
}

Je me posais la question suivante : faut-il tester chacune des allocations, de cette façon ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* allocation de l'espace necessaire */
 
dico = malloc(sizeof(*dico) * nb_mots); 
 
if(dico != NULL)
{
   for(i = 0; i < nb_mots; ++i)
   {
      dico[i] = malloc(sizeof(**dico) * TAILLE_MOT_MAX);
      if(dico[i] == NULL)
      {
         printf("erreur d'allocation dynamique, le programme va se fermer\n")
         exit(0);
      }
   }
}
 
else
{
   printf("erreur d'allocation dynamique, le programme va se fermer\n")
   exit(0);
}

Par avance, merci.

11/06/2007, 12h09
GyZmoO

Salut, pour chaque malloc calloc etc... il te faut tester la valeur de retour.

A savoir aussi, si a un moment donné, une allocation échoue, il faut que tu libères l'espace que tu as déja alloué (si tu en as déja alloué...)

Citation:

A savoir aussi, si a un moment donné, une allocation échoue, il faut que tu libères l'espace que tu as déja alloué (si tu en as déja alloué...)

Exact...
Ceci peut-il convenir ?

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
 
/* allocation de l'espace necessaire */
 
dico = malloc(sizeof(*dico) * nb_mots); 
 
if(dico != NULL)
{
   for(i = 0; i < nb_mots; ++i)
   {
      dico[i] = malloc(sizeof(**dico) * TAILLE_MOT_MAX);
      if(dico[i] == NULL)
      {
         printf("erreur d'allocation dynamique, le programme va se fermer\n");
 
         /* on libere ce qui a deja ete alloue */
         size_t j;
         for(j = 0; j < i; ++j)
         {
            free(dico[j]), dico[j] = NULL;
         }
         free(dico), dico = NULL;
         exit(0);
      }
   }
}
 
else
{
   printf("erreur d'allocation dynamique, le programme va se fermer\n");
   exit(0);
}

Citation:

Envoyé par odsen.s

J'ai besoin d'allouer dynamiquement un tableau à deux dimensions.
J'ai donc suivi la méthode de la FAQ :

Il y a plusieurs méthodes possibles. Il faut déterminer si une erreur d'allocation est bloquante ou non. En principe, la fonction d'allocation n'en sait rien et se contente de faire un travail mais de la faire bien.
par exemple :

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
63
64
65
66
67
68
69
70
71
 
#include <stdio.h>
#include <stdlib.h>
 
typedef double T;
 
struct tab
{
   T **a;
   size_t nblin;
   size_t nbcol;
};
 
 
void tab_delete (struct tab *this)
{
   if (this != NULL)
   {
      if (this->a != NULL)
      {
         size_t i;
         for (i = 0; i < this->nblin; i++)
         {
            free (this->a[i]), this->a[i] = NULL;
         }
         free (this->a);
      }
      free (this), this = NULL;
   }
}
 
struct tab *tab_create(size_t nblin, size_t nbcol)
{
   struct tab *this = malloc (sizeof *this);
   if (this != NULL)
   {
      this->nblin = nblin;
      this->nbcol = nbcol;
      this->a = malloc (sizeof * this->a * this->nblin);
 
      if (this-> a != NULL)
      {
         int err = 0;
         size_t i;
         for (i = 0; i < this->nblin; i++)
         {
             this->a[i] = malloc (sizeof *this->a[i] * this->nblin);
             err = this->a[i] == NULL;
         }
         if (err)
         {
             tab_delete (this), this = NULL;
         }
      }
   }
   return this;
}
 
int main (void)
{
   struct tab *tab = tab_create(2, 4);
 
   if (tab != NULL)
   {
      /* utilisation */
 
      tab_delete (tab);
   }
 
   return 0;
}

11/06/2007, 15h17
souviron34

Citation:

Envoyé par GyZmoO

Salut, pour chaque malloc calloc etc... il te faut tester la valeur de retour.

A savoir aussi, si a un moment donné, une allocation échoue, il faut que tu libères l'espace que tu as déja alloué (si tu en as déja alloué...)

Pas forcément...

Tout dépend de ce que tu veux faire par la suite..

Si ton code est fullproof, quand tu vas te servir d'un élément tu vérifies si il est NULL ou pas...

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
63
64
65
66
67
68
69
70
71
 
#include <stdio.h>
#include <stdlib.h>
 
typedef double T;
 
struct tab
{
   T **a;
   size_t nblin;
   size_t nbcol;
};
 
 
void tab_delete (struct tab *this)
{
   if (this != NULL)
   {
      if (this->a != NULL)
      {
         size_t i;
         for (i = 0; i < this->nblin; i++)
         {
            free (this->a[i]), this->a[i] = NULL;
         }
         free (this->a);
      }
      free (this), this = NULL;
   }
}
 
struct tab *tab_create(size_t nblin, size_t nbcol)
{
   struct tab *this = malloc (sizeof *this);
   if (this != NULL)
   {
      this->nblin = nblin;
      this->nbcol = nbcol;
      this->a = malloc (sizeof * this->a * this->nblin);
 
      if (this-> a != NULL)
      {
         int err = 0;
         size_t i;
         for (i = 0; i < this->nblin; i++)
         {
             this->a[i] = malloc (sizeof *this->a[i] * this->nblin);
             err |= this->a[i] == NULL; /* edit */
         }
         if (err)
         {
             tab_delete (this), this = NULL;
         }
      }
   }
   return this;
}
 
int main (void)
{
   struct tab *tab = tab_create(2, 4);
 
   if (tab != NULL)
   {
      /* utilisation */
 
      tab_delete (tab);
   }
 
   return 0;
}

Merci.
Je me suis inspiré du code pour faire mes fonctions.
Juste une petite question : si l'allocation de la seconde dimension échoue à un moment, ne serait-il pas préférable de sortir immédiatement de la boucle et ne pas continuer les allocations ? De plus, est-il possible qu'une allocation (i) de seconde dimension échoue, et que celle d'après (i+1) réussisse ? Car err sera alors à zéro, et le programme se comportera ensuite comme si toutes les allocations avaient réussi.

11/06/2007, 15h56
souviron34

Citation:

Envoyé par odsen.s

Juste une petite question : si l'allocation de la seconde dimension échoue à un moment, ne serait-il pas préférable de sortir immédiatement de la boucle et ne pas continuer les allocations ? De plus, est-il possible qu'une allocation (i) de seconde dimension échoue, et que celle d'après (i+1) réussisse ? Car err sera alors à zéro, et le programme se comportera ensuite comme si toutes les allocations avaient réussi.

Comme je disais, je ne sais pas quelle application tu veux faire, mais oui en général il est préférable de sortir de la boucle et de ne pas continuer.

Et la réponse est aussi oui à ta deuxième question : il est possible qu'une allocation échoue et la suivante réussisse (un autre programme s'est arrêté entre temps et a libéré de la place, par exemple).

Et donc dans ce cas, ce que je fait c'est mettre 2 variables d'erreur : 1 qui est à chaque allocation, et une globale qui est mise a erreur si un des résultats est une erreur..
11/06/2007, 15h59
odsen.s

Eh bien, merci :)
Je pense que j'ai tout ce que je souhaitais savoir.
11/06/2007, 16h09
Emmanuel Delahaye

Citation:

Envoyé par odsen.s

Juste une petite question : si l'allocation de la seconde dimension échoue à un moment, ne serait-il pas préférable de sortir immédiatement de la boucle et ne pas continuer les allocations ? De plus, est-il possible qu'une allocation (i) de seconde dimension échoue, et que celle d'après (i+1) réussisse ? Car err sera alors à zéro, et le programme se comportera ensuite comme si toutes les allocations avaient réussi.

Exact, je me suis trompé, je corrige.
12/06/2007, 14h15
Médinoc

La création dynamique d'un tableau à deux dimensions dépend de la souplesse nécessaire: S'il sera nécessaire de réallouer le tableau, la technique du "tableau de tableaux" peut être la meilleure.

En revanche, si la taille ne doit pas varier après l'allocation, il est plus simple de se limiter à une allocation par dimension:
http://www.developpez.net/forums/sho...70&postcount=7