Maîtriser les pointeurs et tableaux multidimensionnels en C

En langage C, un tableau est une collection de valeurs de type similaire stockées dans des emplacements mémoire contigus. Chaque élément dans un tableau (unidimensionnel ou multidimensionnel) est identifié par un ou plusieurs indices entiers uniques.

Un pointeur, d'autre part, stocke l'adresse d'une variable. L'adresse de l'élément 0 dans un tableau est le pointeur du tableau. Vous pouvez utiliser l'« opérateur de déréférencement » pour accéder à la valeur qu'un pointeur 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'indice 0, « 2 » à l'indice 1, et ainsi de suite.

Une variable qui stocke l'adresse de l'élément 0 est son pointeur −

int *x = &a[0];

Simplement, le nom du tableau pointe aussi vers l'adresse de l'élément 0. Donc, vous pouvez aussi 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 dans le 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

Quand vous exécutez ce code, il produit la sortie suivante −

arr[0]: 1
arr[1]: 2
arr[2]: 3
arr[3]: 4
arr[4]: 5

Pointeurs et tableaux bidimensionnels

Si un tableau unidimensionnel est comme une liste d'éléments, un tableau bidimensionnel est comme un tableau ou une matrice.

Les éléments dans un tableau 2D peuvent être considérés comme logiquement organisés en lignes et colonnes. Donc, la localisation de tout élément est décidée par deux indices, son numéro de ligne et numéro de colonne. Les index de ligne et colonne commencent tous deux à « 0 ».

int arr[2][2];

Un tel tableau est représenté comme −

	Col0	Col1	Col2
Row0	arr[0][0]	arr[0][1]	arr[0][2]
Row1	arr[1][0]	arr[1][1]	arr[1][2]
Row2	arr[2][0]	arr[2][1]	arr[2][2]

Il peut être noté que l'arrangement tabulaire n'est qu'une représentation logique. Le compilateur alloue un bloc d'octets contigus. En C, l'allocation du tableau se fait de manière row-major, ce qui signifie que les éléments sont lus dans le tableau de manière ligne par ligne.

Ici, on déclare un tableau 2D avec trois lignes et quatre colonnes (le nombre dans 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 pour le tableau 2D ci-dessus dans un ordre row-wise. En supposant que le premier élément du tableau est à l'adresse 1000 et la taille du type « int » est de 4 octets, les éléments du tableau obtiendront les emplacements mémoire alloués suivants −

	Row 0	Row 1	Row 2
Value	1 2 3 4	5 6 7 8	9 10 11 12
Address	1000 1004 1008 1012	1016 1020 1024 1028	1032 1036 1040 1044

On affectera l'adresse du premier élément du tableau num au pointeur ptr en utilisant l'opérateur d'adresse &.

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 dans le tableau « 3x4 » peuvent être accédés dans une boucle comme suit −

#include <stdio.h>
int main(){
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    };
    // pointeur ptr pointant sur le tableau num
    int *ptr = &arr[0][0];
    int i, j, k = 0;
    // afficher les éléments du tableau num via le pointeur ptr
    for (i = 0; i < 3; i++){
        for (j = 0; j < 4; j++){
            printf("%d ", *(ptr + k));
            k++;
        }
        printf("\n");
    }
    return 0;
}

Sortie

Quand vous exécutez ce code, il produit la sortie suivante −

1 2 3 4
5 6 7 8
9 10 11 12

En général, l'adresse de tout élément du tableau peut être obtenue avec la formule suivante −

adresse de l'élément à la i-ème ligne et j-ème colonne = adresseBase + [(i * nb_colonnes + j) * sizeof(type_tableau)]

Dans notre tableau 3x4,

adresse de arr[2][2] = 1000 + (2*4 + 2)*4 = 1044

Vous pouvez vous référer à la figure ci-dessus et elle confirme que l'adresse de « arr[2][2] » est 1044 (note : l'original disait arr[3][4] mais les indices sont 0-based, donc arr[2][2] est le 3ème ligne, 3ème colonne).

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 avec l'aide de son pointeur −

#include <stdio.h>
int main(){
    // tableau 2d
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    int ROWS = 3, COLS = 4;
    int i, j;
    // pointeur
    int *ptr = &arr[0][0];
    // afficher l'élément du tableau via le pointeur ptr
    for (i = 0; i < ROWS; i++){
        for (j = 0; j < COLS; j++) {
            printf("%4d ",*(ptr + (i * COLS + j)));
        }
        printf("\n");
    }
    return 0;
}

Sortie

Quand vous exécutez ce code, il produit la sortie suivante −

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 « x » nombre de couches de tableaux, chaque tableau 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 que le nom du tableau lui-même est l'adresse de l'élément 0, on peut écrire le pointeur d'un tableau 3D comme −

int * ptr = arr;

Chaque couche de « x » lignes et « y » colonnes occupe −

x * y * sizeof(type_donnees)

Nombre d'octets. En supposant que la mémoire allouée au tableau 3D « arr » comme déclaré ci-dessus commence à l'adresse 1000, la deuxième couche (avec « i = 1 ») commence à 1000 + (3 * 3) * 4 = 1036 position d'octet.

ptr = Adresse de base du tableau 3D 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 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 k-ème colonne de la i-ème tranche peut être donnée comme −

arr[i][j][k] = *(ptr + (i * JMAX*KMAX) + (j*KMAX + k))

Exemple : Affichage d'un tableau 3D en utilisant le déréférencement de pointeur

Utilisons cette formule pour afficher le tableau 3D avec 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

Quand vous exécutez ce code, il produit la sortie suivante −

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 par indices. La différence principale entre les deux est que la déclaration indicée d'un tableau alloue la mémoire statiquement, alors qu'on peut utiliser des pointeurs pour l'allocation mémoire dynamique.

Pour passer un tableau multidimensionnel à une fonction, vous devez utiliser des pointeurs au lieu d'indices. Cependant, utiliser un tableau indicé est plus pratique que d'utiliser des pointeurs, ce qui peut être difficile pour les nouveaux apprenants.