Pourquoi les tableaux multidimensionnels se désintègrent-ils en pointeurs différemment des tableaux unidimensionnels ?

Pourquoi les tableaux se décomposent en pointeurs différemment en fonction de la dimensionnalité

Introduction

Lorsque vous travaillez avec des tableaux et des pointeurs, il est important de comprendre comment se produit la dégradation des types. . Bien que vous puissiez vous attendre à ce que les tableaux bidimensionnels se décomposent en pointeurs doubles, ce n'est pas toujours le cas. Voyons pourquoi cela se produit et explorons la différence de comportement.

Dégradation des tableaux unidimensionnels

Comme le démontre le scénario de test, les tableaux unidimensionnels se désintègrent en effet en pointeurs uniques :

<code class="cpp">std::is_same<int*, std::decay<int[]>::type>::value; // true</code>

En effet, l'arithmétique des pointeurs peut être effectuée avec un seul pointeur.

Dégradation des tableaux multidimensionnels

Cependant, les tableaux bidimensionnels ne se désintègrent pas en pointeurs doubles :

<code class="cpp">std::is_same<int**, std::decay<int[][1]>::type>::value; // false</code>

La raison est que les doubles pointeurs nécessitent des informations supplémentaires sur les dimensions du tableau. Par exemple, dans le cas de int[5][4], le compilateur sait que chaque tableau "interne" a une longueur de 4. La conversion en int (*)[4] conserve ces informations, ce qui rend possible l'arithmétique des pointeurs.

Cependant, le casting vers int ** perd ces informations de dimension. Il devient simplement un pointeur vers un pointeur, ce qui n'est pas suffisant pour effectuer une arithmétique de pointeur significative.

Comprendre la différence

Considérez ce qui suit :

<code class="cpp">char *tmp = (char *)p           // Work in units of bytes (char)
          + i * sizeof(int[4])  // Offset for outer dimension (int[4] is a type)
          + j * sizeof(int);    // Offset for inner dimension
int a = *(int *)tmp;            // Back to the contained type, and dereference</code>

Ce code effectue manuellement l'accès au tableau, démontrant que le compilateur s'appuie sur les informations de dimension. int** ne fournit pas cette information, ce qui le rend impropre à l'arithmétique des pointeurs.

Conclusion

Alors que les tableaux unidimensionnels se désintègrent en pointeurs simples, les tableaux multidimensionnels ne se désintègrent pas en pointeurs doubles. car ils ne disposent pas des informations de dimension nécessaires. Ce comportement garantit qu'une arithmétique de pointeur significative reste possible avec des pointeurs à une seule dimension.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!