Façon bizarre d'allouer un tableau à deux dimensions?

Dans un projet, quelqu'un a poussé cette ligne:

double (*e)[n+1] = malloc((n+1) * sizeof(*e));

Ce qui crée supposément un tableau bidimensionnel de (n + 1) * (n + 1) doubles.

Soi -disant, dis-je, parce que jusqu'à présent, personne à qui j'ai demandé ne pouvait me dire ce que cela faisait exactement, ni d'où cela venait ni pourquoi cela devrait fonctionner (ce qui serait prétendument le cas, mais je ne l'achète pas encore).

Peut-être que je manque quelque chose d'évident, mais j'apprécierais que quelqu'un puisse m'expliquer ci-dessus. Parce que personnellement, je me sentirais beaucoup mieux si nous utilisions quelque chose que nous comprenons réellement.

La variable eest un pointeur vers un tableau d' n + 1éléments de type double.

L'utilisation de l'opérateur de déréférence sur evous donne le type de base edont est "tableau d' n + 1éléments de type double".

L' mallocappel prend simplement le type de base de e(expliqué ci-dessus) et obtient sa taille, la multiplie par n + 1et en passant cette taille à la mallocfonction. Allouant essentiellement un tableau de n + 1tableaux d' n + 1éléments de double.

C'est la manière habituelle d'allouer des tableaux 2D de manière dynamique.

• eest un pointeur de tableau vers un tableau de type double [n+1].
• sizeof(*e)donne donc le type du type pointé, qui est la taille d'un double [n+1]tableau.
• Vous allouez de la place pour n+1ces tableaux.
• Vous définissez le pointeur de tableau epour qu'il pointe sur le premier tableau de ce tableau de tableaux.
• Cela vous permet d'utiliser eas e[i][j]pour accéder à des éléments individuels dans le tableau 2D.

Personnellement, je pense que ce style est beaucoup plus facile à lire:

double (*e)[n+1] = malloc( sizeof(double[n+1][n+1]) );

Cet idiome sort naturellement de l'allocation de tableau 1D. Commençons par allouer un tableau 1D d'un type arbitraire T:

T *p = malloc( sizeof *p * N );

Simple, non? L' expression *p a un type T, donc sizeof *pdonne le même résultat que sizeof (T), donc nous Nallouons suffisamment d'espace pour un tableau -element de T. Cela est vrai pour tout typeT .

Maintenant, remplaçons Tpar un type de tableau comme R [10]. Alors notre allocation devient

R (*p)[10] = malloc( sizeof *p * N);

La sémantique ici est exactement la même que celle de la méthode d'allocation 1D; tout ce qui a changé est le type de p. Au lieu de T *, c'est maintenant R (*)[10]. L'expression *pa un type Tqui est type R [10], donc sizeof *pest équivalent à sizeof (T)qui est équivalent à sizeof (R [10]). Nous allouons donc suffisamment d'espace pour un tableau Npar 10élément de R.

Nous pouvons aller encore plus loin si nous le voulons; suppose Rest lui-même un type de tableau int [5]. Remplacez cela Ret nous obtenons

int (*p)[10][5] = malloc( sizeof *p * N);

Même accord - sizeof *pest le même que sizeof (int [10][5]), et nous finissons par allouer un morceau de mémoire contigu assez grand pour contenir un Npar 10par 5tableau de int.

Voilà donc le côté allocation; qu'en est-il du côté accès?

N'oubliez pas que l' []opération d'indice est définie en termes d'arithmétique de pointeur: a[i]est définie comme *(a + i)¹ . Ainsi, l'opérateur d'indice déréférence [] implicitement un pointeur. Si pest un pointeur vers T, vous pouvez accéder à la valeur pointée soit en déréférençant explicitement avec l' *opérateur unaire :

T x = *p;

ou en utilisant l' []opérateur indice:

T x = p[0]; // identical to *p

Ainsi, si ppointe sur le premier élément d'un tableau , vous pouvez accéder à n'importe quel élément de ce tableau en utilisant un indice sur le pointeur p:

T arr[N];
T *p = arr; // expression arr "decays" from type T [N] to T *
...
T x = p[i]; // access the i'th element of arr through pointer p

Maintenant, refaisons notre opération de substitution et remplaçons Tpar le type de tableau R [10]:

R arr[N][10];
R (*p)[10] = arr; // expression arr "decays" from type R [N][10] to R (*)[10]
...
R x = (*p)[i];

Une différence immédiatement apparente; nous déréférencons explicitement pavant d'appliquer l'opérateur indice. Nous ne voulons pas souscrire p, nous voulons indiquer ce qui p pointe vers (dans ce cas, le tableau arr[0] ). Étant donné que l'unaire *a une priorité inférieure à l' []opérateur indice , nous devons utiliser des parenthèses pour regrouper explicitement pavec *. Mais rappelez-vous d'en haut que *pc'est la même chose que p[0], donc nous pouvons le remplacer par

R x = (p[0])[i];

ou juste

R x = p[0][i];

Ainsi, si ppointe vers un tableau 2D, nous pouvons indexer ce tableau pcomme suit:

R x = p[i][j]; // access the i'th element of arr through pointer p;
               // each arr[i] is a 10-element array of R

Prenant cela à la même conclusion que ci-dessus et en remplaçant Rpar int [5]:

int arr[N][10][5];
int (*p)[10][5]; // expression arr "decays" from type int [N][5][10] to int (*)[10][5]
...
int x = p[i][j][k];

Cela fonctionne exactement de la même manière s'il ppointe vers un tableau normal ou s'il pointe vers la mémoire allouée via malloc.

Cet idiome présente les avantages suivants:

1. C'est simple - juste une ligne de code, par opposition à la méthode d'allocation fragmentaire

   T **arr = malloc( sizeof *arr * N );
   if ( arr )
   {
     for ( size_t i = 0; i < N; i++ )
     {
       arr[i] = malloc( sizeof *arr[i] * M );
     }
   }

2. Toutes les lignes du tableau alloué sont * contiguës *, ce qui n'est pas le cas avec la méthode d'allocation fragmentaire ci-dessus;
3. Désallouer le tableau est tout aussi simple avec un seul appel à free. Encore une fois, ce n'est pas vrai avec la méthode d'allocation au coup par coup, où vous devez désallouer chacun arr[i]avant de pouvoir désallouer arr.

Parfois, la méthode d'allocation fragmentaire est préférable, par exemple lorsque votre tas est gravement fragmenté et que vous ne pouvez pas allouer votre mémoire en tant que bloc contigu, ou que vous souhaitez allouer un tableau "en dents de scie" où chaque ligne peut avoir une longueur différente. Mais en général, c'est la meilleure façon de procéder.