Discussion :

[odsen.s]

Bonjour,

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

Code :

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

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 :

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

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

[odsen.s]

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 :

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
 
/* 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);
}

[Emmanuel Delahaye]

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 :

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

[souviron34]

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

[odsen.s]

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 :

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

[souviron34]

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

[odsen.s]

Eh bien, merci
Je pense que j'ai tout ce que je souhaitais savoir.

[Emmanuel Delahaye]

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.

[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