Tableau 2D

Un tableau à deux dimensions (2D) est un tableau de tableaux à une dimension (1D). Les tailles de tableau 1D sont égales. Le tableau 2D est également appelé une matrice avec des lignes et des colonnes.

Voyons l'exemple suivant :

Ces 3 tableaux 1D peuvent être représentés comme un tableau 2D comme suit :

Voyons un autre exemple :

Ces 3 tableaux 1D ne peuvent pas être représentés comme un tableau 2D car les tailles des tableaux sont différentes.

Déclaration de tableau 2D

Type de données nom_tableau[LIGNE][COL]

Type de données est le type de données des éléments du tableau.
Array-name est le nom du tableau.
Deux indices représentent le nombre de lignes et de colonnes du tableau. Le nombre total d'éléments du tableau sera ROW*COL.

int a[2][3];

En utilisant le code C ci-dessus, nous pouvons déclarer un entier déployer, une de taille 2*3 (2 lignes et 3 colonnes).

car b[3][2];

En utilisant le code C ci-dessus, nous pouvons déclarer un personnage déployer, b de taille 2*3 (3 lignes et 2 colonnes).

Initialisation du tableau 2D

Nous pouvons initialiser lors de la déclaration des manières suivantes :

int a[3][2] = 1,2,3,4,5,6 ;
int a[][2] = 1,2,3,4,5,6 ;
int a[3][2] = 1, 2,3, 4,5, 6 ;
int a[][2] = 1, 2,3, 4,5, 6 ;

Notez qu'en 2 et 4 nous n'avons pas mentionné le 1^st indice. Le compilateur C calcule automatiquement le nombre de lignes à partir du nombre d'éléments. Mais le 2^sd l'indice doit être spécifié. Les initialisations suivantes ne sont pas valides :

int a[3][] = 1,2,3,4,5,6 ;
int a[][] = 1,2,3,4,5,6 ;

1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//Exemple 1.c
#inclure
#définir la ligne 3
#définir COL 2
int main()

int i,j;
int a[ROW][COL] =
1,2,
3,4,
5,6
;
printf("Les éléments en ligne du tableau a sont :\n");
pour(i=0;i
printf("Ligne %d :",i);
pour(j=0;j
printf(" %d",a[i][j]);

printf("\n");

printf("\n\nLes éléments en colonnes du tableau a sont :\n");
pour(i=0;i
printf("Colonne %d :",i);
pour(j=0;j
printf(" %d",a[j][i]);

printf("\n");

renvoie 0 ;

Dans Exemple1.c, nous avons déclaré un tableau d'entiers de taille 3*2 et initialisé. Pour accéder aux éléments du tableau, nous utilisons deux boucles for.

Pour accéder par ligne, la boucle externe est pour les lignes et la boucle interne est pour les colonnes.

Pour accéder au niveau des colonnes, la boucle externe est pour les colonnes et la boucle interne est pour les lignes.

Notez que lorsque nous déclarons un tableau 2D, nous utilisons a[2][3], ce qui signifie 2 lignes et 3 colonnes. L'indexation des tableaux commence à partir de 0. Pour accéder aux 2^sd rangée et 3^rd colonne, nous devons utiliser la notation a[1][2].

Mappage mémoire d'un tableau 2D

La vue logique d'un tableau a[3][2] peut être la suivante :

La mémoire de l'ordinateur est une séquence 1D d'octets. En langage C, un tableau 2D stocké en mémoire dans ordre de ligne principale. Certains autres langages de programmation (e.g., FORTRAN), il stocke dans ordre majeur des colonnes dans la mémoire.

Arithmétique du pointeur d'un tableau 2D

Pour comprendre l'arithmétique du pointeur du tableau 2D, regardez d'abord le tableau 1D.

Considérons un tableau 1D :

En tableau 1D, une est une constante, et sa valeur est l'adresse du 0^e emplacement du tableau un[5]. Valeur de a+1 est l'adresse du 1^st emplacement du tableau un[5]. a+i est l'adresse du je^e emplacement du tableau.

Si on incrémente une de 1, il est incrémenté de la taille du type de données.

un[1] est équivalent à *(a+1)

un[2] est équivalent à *(a+2)

un[i] est équivalent à *(a+i)

1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18
19
20
21

//Exemple2.c
#inclure
#définir la ligne 3
#définir COL 2
int main()

int a[5]=10,20,30,40,50 ;
printf("sizeof(int) : %ld\n\n",sizeof(int));
printf("a : %p\n",a);
printf("a+1 : %p\n",a+1);
printf("a+2 : %p\n\n",a+2);
printf("a[1] : %d, *(a+1) : %d\n",a[1],*(a+1));
printf("a[2] : %d, *(a+2) : %d\n",a[1],*(a+1));
printf("a[3] : %d, *(a+3) : %d\n",a[1],*(a+1));
renvoie 0 ;

Dans Exemple2.c, l'adresse mémoire s'affiche en hexadécimal. La différence entre a et a+1 est de 4, ce qui correspond à la taille d'un entier en octets.

Considérons maintenant un tableau 2D :

b est un pointeur de type : entier[ ][4] ou alors entier(*)[4]

entier[ ][4] est une ligne de 4 entiers. Si on incrémente b de 1, il est incrémenté de la taille de la ligne.

b est l'adresse du 0^e ligne.

b+1 est l'adresse du 1^st ligne.

b+i est l'adresse de je^e ligne.

La taille d'une ligne est : (Nombre de colonne * sizeof(data-type)) octets

La taille d'une ligne d'un tableau d'entiers b[3][4] est : 4 * sizeof(int) = 4 * 4 = 16 octets

Une ligne d'un tableau 2D peut être considérée comme un tableau 1D. b est l'adresse du 0^e ligne. Donc, on obtient ce qui suit

*b+1 est l'adresse du 1^st élément de la 0^e
*b+j est l'adresse du j^e élément de la 0^e
*(b+i) est l'adresse du 0^e élément de la je^e
*(b+i)+j est l'adresse du j^e élément de la je^e
b[0][0] équivaut à **b
b[0][1] équivaut à *(*b+1)
b[1][0] équivaut à *(*(b+1))
b[1][1] équivaut à *(*(b+1)+1)
b[i][j] équivaut à *(*(b+i)+j)

Adresse de b[i][j] : b + sizeof(data-type) * (Numéro de colonne * i + j)

Considérons un tableau 2D : entier b[3][4]

L'adresse de b[2][1] est : b + taillede(int) * (4*2 + 1)

1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

//Exemple3.c
#inclure
#définir la ligne 3
#définir COL 4
int main()

int i,j;
entier b[ROW][COL] =
10,20,30,40,
50,60,70,80,
90 100 110 120
;
printf("sizeof(int): %ld\n",sizeof(int));
printf("Taille d'une ligne : %ld\n",COL*sizeof(int));
printf("b : %p\n",b);
printf("b+1 : %p\n",b+1);
printf("b+2 : %p\n",b+2);
printf("*b : %p\n",*b);
printf("*b+1 : %p\n",*b+1);
printf("*b+2 : %p\n",*b+2);
printf("b[0][0] : %d **b : %d\n",b[0][0],**b);
printf("b[0][1] : %d *(*b+1) : %d\n",b[0][1],*(*b+1));
printf("b[0][2] : %d *(*b+2) : %d\n",b[0][2],*(*b+2));
printf("b[1][0] : %d *(*(b+1)): %d\n",b[1][0],*(*(b+1)));
printf("b[1][1] : %d *(*(b+1)+1) : %d\n",b[1][1],*(*(b+1)+1) );
renvoie 0 ;

Dans l'exemple3.c, nous avons vu que la taille d'une ligne est de 16 en notation décimale. La différence entre b+1 et b est de 10 en hexadécimal. 10 en hexadécimal équivaut à 16 en décimal.

Conclusion

Ainsi, dans cet article, nous avons appris

Déclaration de tableau 2D
Initialisation du tableau 2D
Mappage mémoire du tableau 2D
Arithmétique du pointeur du tableau 2D

Maintenant, nous pouvons utiliser le tableau 2D dans notre programme C sans aucun doute,

Les références

Le crédit pour certaines idées de ce travail a été inspiré par le cours, Pointers and 2-D Arrays, par Palash Dey Department of Computer Science & Engg. Institut indien de technologie Kharagpur