Maîtriser les pointeurs et les tableaux multidimensionnels en C
En langage C, un tableau est une collection de valeurs de type similaire stockées dans des emplacements mémoire continus. Chaque élément d'un tableau (unidimensionnel ou multidimensionnel) est identifié par un ou plusieurs indices entiers uniques.
Un pointeur, quant à lui, stocke l’adresse d’une variable. L'adresse du 0ème élément d'un tableau est le pointeur du tableau. Vous pouvez utiliser "l'opérateur de déréférencement" pour accéder à la valeur à laquelle un pointeur fait référence.
Vous pouvez déclarer un tableau unidimensionnel, bidimensionnel ou multidimensionnel en C. Le terme « dimension » fait référence au nombre d'indices requis pour identifier un élément dans une collection.
Pointeurs et tableaux unidimensionnels
Dans un tableau unidimensionnel, chaque élément est identifié par un seul entier :
int a[5] = {1, 2, 3, 4, 5};
Ici, le nombre "1" est à l'index 0, "2" à l'index 1, et ainsi de suite.
Une variable qui stocke l'adresse du 0ème élément est son pointeur −
int *x = &a[0];
Simplement, le nom du tableau pointe également vers l’adresse du 0ème élément. Donc, vous pouvez également utiliser cette expression −
int *x = a;
Exemple
Puisque la valeur du pointeur s'incrémente de la taille du type de données, "x++" déplace le pointeur vers l'élément suivant du tableau.
#include <stdio.h>
int main(){
int arr[] = {1, 2, 3, 4, 5};
int length = sizeof(arr) / sizeof(arr[0]);
int i = 0;
int *ptr = arr;
while (i < length){
printf("arr[%d]: %d \n", i, *(ptr + i));
i++;
}
return 0;
}
Sortie
Lorsque vous exécutez ce code, il produira le résultat suivant -
arr[0]: 1 arr[1]: 2 arr[2]: 3 arr[3]: 4 arr[4]: 5
Pointeurs et tableaux bidimensionnels
Si un tableau à une dimension ressemble à une liste d'éléments, un tableau à deux dimensions est comme un tableau ou une matrice.
Les éléments d’un tableau 2D peuvent être considérés comme étant logiquement disposés en lignes et en colonnes. Par conséquent, l’emplacement de tout élément est déterminé par deux indices, son numéro de ligne et son numéro de colonne. Les index de lignes et de colonnes commencent à "0".
int arr[2][2];
Un tel tableau est représenté par −
On peut noter que la disposition tabulaire n’est qu’une représentation logique. Le compilateur alloue un bloc d'octets continus. En C, l'allocation du tableau se fait par ligne principale, ce qui signifie que les éléments sont lus dans le tableau par ligne.
Ici, nous déclarons un tableau 2D avec trois lignes et quatre colonnes (le nombre entre le premier crochet fait toujours référence au nombre de lignes) comme −
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
Le compilateur allouera la mémoire au tableau 2D ci-dessus dans un ordre par ligne. En supposant que le premier élément du tableau est à l'adresse 1000 et que la taille du type "int" est de 4 octets, les éléments du tableau obtiendront les emplacements mémoire alloués suivants -
Nous attribuerons l'adresse du premier élément du tableau num au pointeur ptr en utilisant l'adresse de l'opérateur &.
int *ptr = &arr[0][0];
Exemple 1
Si le pointeur est incrémenté de 1, il passe à l'adresse suivante. Tous les 12 éléments du tableau "34" sont accessibles en boucle comme suit −
#include <stdio.h>
int main(){
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
};
// pointer ptr pointing at array num
int *ptr = &arr[0][0];
int i, j, k = 0;
// print the elements of the array num via pointer ptr
for (i = 0; i < 3; i++){
for (j = 0; j < 4; j++){
printf("%d ", *(ptr + k));
k++;
}
printf("\n");
}
return 0;
}
Sortie
Lorsque vous exécutez ce code, il produira le résultat suivant -
1 2 3 4 5 6 7 8 9 10 11 12
En général, l'adresse de n'importe quel élément du tableau en utilisant la formule suivante −
add of element at ith row and jth col = baseAddress + [(i * no_of_cols + j) * sizeof(array_type)]
Dans notre tableau 34,
add of arr[2][4] = 1000 + (2*4 + 2)*4 = 1044
Vous pouvez vous référer à la figure ci-dessus et elle confirme que l'adresse de "arr[3][4]" est 1044.
Exemple 2
Utilisez le pointeur de déréférencement pour récupérer la valeur à l'adresse. Utilisons cette formule pour parcourir le tableau à l'aide de son pointeur −
#include <stdio.h>
int main(){
// 2d array
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
int ROWS = 3, COLS = 4;
int i, j;
// pointer
int *ptr = &arr[0][0];
// print the element of the array via pointer ptr
for (i = 0; i < ROWS; i++){
for (j = 0; j < COLS; j++) {
printf("%4d ",*(ptr + (i * COLS + j)));
}
printf("\n");
}
return 0;
}
Sortie
Lorsque vous exécutez ce code, il produira le résultat suivant -
1 2 3 4 5 6 7 8 9 10 11 12
Pointeurs et tableaux tridimensionnels
Un tableau tridimensionnel est un tableau de tableaux bidimensionnels. Un tel tableau est déclaré avec trois indices −
int arr [x] [y] [j];
Ce tableau peut être considéré comme un nombre "x" de couches de tables, chaque table ayant "x" lignes et "y" nombre de colonnes.
Un exemple de tableau 3D est −
int arr[3][3][3] ={
{ {11, 12, 13}, {14, 15, 16}, {17, 18, 19} },
{ {21, 22, 23}, {24, 25, 26}, {27, 28, 29} },
{ {31, 32, 33}, {34, 35, 36}, {37, 38, 39} },
};
Un pointeur vers le tableau 3D peut être déclaré comme −
int * ptr = &arr[0][0][0];
Sachant cela, le nom du tableau lui-même est l'adresse du 0ème élément, nous pouvons écrire le pointeur d'un tableau 3D comme −
int * ptr = arr;
Chaque couche de lignes "x" et de colonnes "y" occupe −
x * y * sizeof(data_type)
Nombre d'octets. En supposant que la mémoire allouée au tableau 3D "arr" comme déclaré ci-dessus commence à partir de l'adresse 1000, la deuxième couche (avec "i =1") commence à 1000 + (3 3) 4 =1036 octets.
ptr = Base address of 3D array arr
Si JMAX est le nombre de lignes et KMAX est le nombre de colonnes, alors l'adresse de l'élément à la 0ème ligne et à la 0ème colonne de la 1ère tranche est −
arr[1][0][0] = ptr + (1 * JMAX * KMAX)
La formule pour obtenir la valeur d'un élément à la jème ligne et à la kème colonne de la ième tranche peut être donnée par −
arr[i][j][k] = *(ptr + (i * JMAX*KMAX) + (j*KMAX + k))
Exemple :Impression d'un tableau 3D à l'aide du déréférencement de pointeur
Utilisons cette formule pour imprimer le tableau 3D à l'aide du déréférencement de pointeur −
#include <stdio.h>
int main(){
int i, j, k;
int arr[3][3][3] = {
{ {11, 12, 13}, {14, 15, 16}, {17, 18, 19} },
{ {21, 22, 23}, {24, 25, 26}, {27, 28, 29} },
{ {31, 32, 33}, {34, 35, 36}, {37, 38, 39} },
};
int JMAX = 3, KMAX = 3;
int *ptr = arr; // &arr[0][0][0];
for(i = 0; i < 3; i++){
for(j = 0; j < 3; j++){
for(k = 0; k < 3; k++){
printf("%d ",*(ptr+(i*JMAX*KMAX)+(j*KMAX+k)));
}
printf("\n");
}
printf("\n");
}
return 0;
}
Sortie
Lorsque vous exécutez ce code, il produira le résultat suivant -
11 12 13 14 15 16 17 18 19 21 22 23 24 25 26 27 28 29 31 32 33 34 35 36 37 38 39
En général, accéder à un tableau avec un pointeur est assez similaire à accéder à un tableau avec une représentation en indice. La principale différence entre les deux est que la déclaration en indice d'un tableau alloue la mémoire de manière statique, alors que nous pouvons utiliser des pointeurs pour une allocation dynamique de la mémoire.
Pour transmettre un tableau multidimensionnel à une fonction, vous devez utiliser des pointeurs au lieu d'indices. Cependant, utiliser un tableau en indice est plus pratique que d'utiliser des pointeurs, ce qui peut être difficile pour les nouveaux apprenants.
Langue C