Pointeurs et tableaux à plusieurs dimensions

▶ En langage C, comme en Java, quand on parle d'un tableau à plusieurs dimensions, on parle de tableaux de tableaux.

Ainsi, un tableau à deux dimensions dont les éléments sont de type T est un tableau de tableaux d'éléments de type T.

Après une définition d'un tableau tab telle que

T tab[4][10];

• sizeof(tab) est égal à « 4 * 10 * sizeof(T) »
• le tableau est un tableau de 4 tableaux de 10 entiers (4 lignes de 10 colonnes);
• tab est une constante de type « pointeur sur tableau de 10 éléments de type T »
c'est-à-dire
• de type incomplet « T (*)[10] » utilisable dans le prototypage d'une fonction ayant un paramètre de ce type;
• de type ptr_tab10T défini par « typedef int (*ptr_tab10T)[10]; »
Sa valeur permet d'accéder au début de la première ligne du tableau.
• de manière générale, pour toute valeur i (normalement comprise entre 0 et 3), tab[i] est un pointeur constant sur un tableau de 10 éléments de type T.
  C'est l'adresse du premier élément de la ligne i du tableau. Une expression qui lui est équivalente est « tab[0] + i »

--> cat tableau2dim.c
#include <stdio.h>
#include <stdlib.h>

/* ptr_tab10T : pointeur sur tableau de 10 éléments de type T */
typedef int (*ptr_tab10int)[10];
ptr_tab10int t1;
void init(int (*)[10]); // prototype de init avec type incomplet pour le paramètre
int t2[4][10];

void init(int (*t)[10]) {
   int i;
   for(i = 0; i < 10; i++)
     (*t)[i] = i + 1;
}

int main ( ) {
   int i;
   t1 = malloc(10 * sizeof(int));
   printf("taille de t1 : %ld\n", sizeof(t1));
   printf("taille de *t1 : %ld\n", sizeof(*t1));
   init(t1);
   for(i = 0; i < 10; i++)
     printf("%d ", (*t1)[i]);
   putchar('\n');
   printf("taille de t2 : %ld\n", sizeof(t2));
   printf("taille de t2[i] : %ld [0x%lx]\n",
           sizeof(t2[0]), sizeof(t2[0]));
   printf("valeur de t2 : %p\n", t2);
   printf("valeur de t2 + 1 : %p\n", t2 + 1);
   t1 = t2 +1;
   if(t2 == &t2[0])
     printf("oui\n");
   else
     printf("non\n");
   if(t2 + 2 == &t2[2])
     printf("oui\n");
   return EXIT_SUCCESS; // return 0;
}
--> ./tableau2dim
1 2 3 4 5 6 7 8 9 10
taille de t1 : 4 <-- t1 est un pointeur
taille de *t1 : 40 <-- l'objet pointé par t est de taille 40 (10 int)
taille de t2 : 160 <-- t2 est un tableau de 40 int
taille de t2[i] : 40 [0x28] <-- une ligne de t2 est un tableau de 10 int
valeur de t2 : 0x2060
valeur de t2 + 1 : 0x2088 <-- +1 signifie augmenter de 40 (0x28)
oui
oui
-->

▶ Dans ce second exemple, on souhaite construire une matrice rectangulaire d'entiers de lig lignes et col colonnes, ces deux nombres n'étant pas connus àla compilation.
La définition sous forme de tableau classique n'étant de ce fait pas possible, on utilise un pointeur de pointeur sur int pour construire le tableau.
Une fois le tableau construit, il est possible d'y accéder par double indexation (ou au travers de pointeurs).

--> cat matrice_pointeur.c
#include <stdio.h>
#include <stdlib.h>
int main() {
   int lig, col, i, j;
   int **mat;
   printf("nombre de lignes ? ");
   scanf("%d", &lig);
   printf("nombre de colonnes ? ");
   scanf("%d", &col);
   mat = (int**) malloc(lig * sizeof(int*));
   for (i = 0; i < lig; i++){
     mat[i] = (int*)malloc(col * sizeof(int));
     for(j = 0; j < col; j++)
       mat[i][j] = lig * i + j;
   }
   for (i = 0; i < lig; i++){
     for(j = 0; j < col; j++)
       printf("%4d ", mat[i][j]);
     putchar('\n');
   }
   return EXIT_SUCCESS; // return 0;
}
--> ./matrice_pointeur
nombre de lignes ? 3
nombre de colonnes ? 4
   0    1    2    3
   3    4    5    6
   6    7    8    9
-->

#include <stdlib.h>
void creer_matrice (int lig, int col, int ***mat) {
   int i, j;
   *mat = (int**) malloc(lig * sizeof(int*));
   for (i = 0; i < lig; i++){
     (*mat)[i] = (int*)malloc(col * sizeof(int));
     for(j = 0; j < col; j++)
       (*mat)[i][j] = lig * i + j;
   }
}

  int lig, col, **mat;
     ...
  creer_matrice(lig, col, &mat);

#include <stdlib.h>
int **creer_matrice (int lig, int col) {
   int i, j;
   int **mat = (int**) malloc(lig * sizeof(int*));
   for (i = 0; i < lig; i++){
     mat[i] = (int*)malloc(col * sizeof(int));
     for(j = 0; j < col; j++)
       mat[i][j] = lig * i + j; // une initialisation comme une autre
   }
   return mat;
}

  int lig, col, **mat;
     ...
  mat = creer_matrice(lig, col);

C'est ce que fait la fonction creer_tableau suivante :

int ** creer_tableau(int lig[], int taille){
   int i, j, **mat;
   mat = (int**) malloc(taille/sizeof(int) * sizeof(int*));
   for(i = 0; i < taille/sizeof(int); i++) {
     mat[i] = (int*)malloc(lig[i] * sizeof(int));
     for(j = 0; j < lig[i]; j++)
       mat[i][j] = taille * i + j; // une initialisation comme une autre
   }
   return mat;
}

--> cat tableau_pointeur.c
#include <stdio.h>
#include <stdlib.h>
int main() {
   int i, j;
   int lig[3] = {5, 8, 3};
   int **mat;
   mat = creer_tableau(lig, sizeof(lig));
   for (i = 0; i < sizeof(lig)/sizeof(int); i++){
     for(j = 0; j < lig[i]; j++)
       printf("%4d ", mat[i][j]);
     putchar('\n');
   }
   // ..... suite du programme
}
--> ./tableau_pointeur
   0 1 2 3 4
  12 13 14 15 16 17 18 19
  24 25 26