Une masortingce int mat est-elle la même chose qu’un int **?

Les tableaux simples à une dimension sont considérés comme un pointeur, mais est-ce également le cas pour une masortingce?

Cependant, un cube int[5][5][5] serait également considéré comme un int *** ?

Non, un pointeur sur un pointeur sur un entier n’est pas identique à un tableau de tableaux de nombres entiers.

Pensez à leur apparence en mémoire.

Tableau de tableaux (par exemple int a[2][2] ):

 + --------- + --------- + --------- + --------- +
 |  a [0] [0] |  a [0] [1] |  a [1] [0] |  a [1] [1] |
 + --------- + --------- + --------- + --------- +

Pointeur sur pointeur (par exemple, int **a ):

 + ------ + ------ + ------ +
 |  un [0] |  a [1] |  .... |
 + ------ + ------ + ------ +
    |  |
    |  v
    |  + --------- + --------- + --------- +
    |  |  A [1] [0] |  a [1] [1] |  ....... |
    |  + --------- + --------- + --------- +
    v
    + --------- + --------- + --------- +
    |  A [0] [0] |  a [0] [1] |  ....... |
    + --------- + --------- + --------- +

Non ils ne sont pas. Par exemple, considérons les deux déclarations données ci-dessous.

 int c[5][5][5]; int ***d; 

Pour la première déclaration, la mémoire requirejse est de 125 X 4 = 500 octets.

Où comme pour la deuxième déclaration l’exigence de mémoire est juste 4 octets. Pour de nombreux objectives pratiques, nous pouvons échanger un tableau et un pointeur, mais ils ne sont pas identiques.

Évidemment pas. Un tableau de tableau d’entiers est différent d’un pointeur à l’autre. Un tableau est une collection d’éléments de données similaires stockés dans un emplacement mémoire contigu. Mais pointeur à pointeur à des entiers ne sont pas.

 int a[5][5]; 

Dans cette déclaration, il atsortingbuera un emplacement mémoire contigu pour tous les éléments. dire l’emplacement de mémoire de départ est 1000.

 array starting array elements address a[0]--> 1000 --> a[0][0] a[0][1] ... a[0][4] a[1]--> 1020 --> a[1][0] a[1][1] ... a[1][4] a[2]--> 1040 --> a[2][0] a[2][1] ... a[2][4] a[3]--> 1060 --> a[3][0] a[3][1] ... a[3][4] a[4]--> 1080 --> a[4][0] a[4][1] ... a[4][4] 

Mais quand vous avez un pointeur à pointeur sur un entier comme ceci-

 int **a; 

lorsque vous allouez de la mémoire pour this-

 array --> a[0] a[1] a[2] a[3] a[4] address > 1000 1004 1008 1012 1016 // address of array which points to some other location 

Ce sera alloué des emplacements de mémoire contigus. mais chaque tableau pointera / tiendra un autre emplacement mémoire pour les éléments.

 array's array element's array elements address address 1000 --> a[0]--> 2000 --> a[0][0] a[0][1] ... a[0][4] 1004 --> a[1]--> 3000 --> a[1][0] a[1][1] ... a[1][4] 1008 --> a[2]--> 4000 --> a[2][0] a[2][1] ... a[2][4] 1012 --> a[3]--> 5000 --> a[3][0] a[3][1] ... a[3][4] 1016 --> a[4]--> 6000 --> a[4][0] a[4][1] ... a[4][4] 

Ces tableaux contiennent l’adresse de départ de leurs éléments dans des emplacements différents.