Tableau 2D

Un tableau bidimensionnel (2D) est un tableau de tableaux unidimensionnels (1D). Les tailles de tableau 1D sont égales. Le tableau 2D est également appelé 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 représenter comme un tableau 2D car les tailles des tableaux sont différentes.

Déclaration de tableau 2D

Type de données nom de tableau[LIGNE] [Col]]

Type de données est le type de données des éléments du tableau.
Le nom de tableau 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, un de taille 2 * 3 (2 lignes et 3 colonnes).

char 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 pendant la déclaration de manière suivante:

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 que dans 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^nd 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
#Define Row 3
#define col 2
int main()

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

printf ("\ n");

printf ("\ n \ ncolumn Les éléments sages du tableau a sont: \ n");
pour (i = 0; i
printf ("colonne% d:", i);
pour (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

retour 0;

Dans l'exemple1.C, nous avons déclaré un tableau entier de taille 3 * 2 et initialisé. Pour accéder aux éléments du tableau, nous en utilisons deux pour Loop.

Pour accéder au niveau des lignes, la boucle extérieure est pour les lignes, et la boucle intérieure est destinée aux colonnes.

Pour accéder au niveau des colonnes, la boucle extérieure est pour les colonnes, et la boucle intérieure est destinée aux lignes.

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

Mappage de mémoire d'un tableau 2D

La vue logique d'un tableau A [3] [2] peut être le suivant:

La mémoire de l'ordinateur est une séquence 1D d'octets. En langue C, un tableau 2D est en mémoire Commande en ligne. Quelques autres langages de programmation (E.g., FORTRAN), il stocke en Ordre de colonne-major en mémoire.

Arithmétique du pointeur d'un tableau 2D

Pour comprendre l'arithmétique du pointeur du tableau 2D, jetez d'abord un œil au tableau 1D.

Considérez un tableau 1D:

Dans un tableau 1D, un est une constante, et sa valeur est l'adresse du 0^e Emplacement du tableau A [5]. Valeur de A + 1 est l'adresse du 1^St Emplacement du tableau A [5]. A + I est l'adresse du je^e Emplacement du tableau.

Si nous incrément un par 1, il est incrémenté par la taille du type de données.

A [1] est équivalent à * (A + 1)

A [2] est équivalent à * (A + 2)

a [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
#Define Row 3
#define 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));
retour 0;

Dans l'exemple2.C, l'adresse mémoire s'affiche en hexadécimal. La différence entre A et A + 1 est 4, ce qui est la taille d'un entier en octets.

Maintenant, considérez un tableau 2D:

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

int [] [4] est une rangée de 4 entiers. Si nous incrément 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 colonnes * sizeof (type de données)) octets

La taille d'une rangée d'un tableau entier B [3] [4] est: 4 * sizeof (int) = 4 * 4 = 16 octets

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

* b + 1 est l'adresse du 1^St élément du 0^e
* B + J est l'adresse du J^e élément du 0^e
* (b + i) est l'adresse du 0^e élément du je^e
* (b + i) + j est l'adresse du J^e élément du je^e
b [0] [0] est équivalent à ** b
b [0] [1] est équivalent à * (* b + 1)
b [1] [0] est équivalent à * (* (b + 1))
b [1] [1] est équivalent à * (* (b + 1) +1)
b [i] [j] est équivalent à * (* (b + i) + j)

Adresse de B [i] [J]: b + sizeof (type de données) * (nombre de colonne * i + j)

Considérez un tableau 2D: int b [3] [4]

L'adresse de b [2] [1] est : b + sizeof (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
#Define Row 3
#define col 4
int main()

int i, j;
int 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) ));
retour 0;

Dans l'exemple3.C, nous avons vu que la taille d'une rangée 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

Donc, dans cet article, nous avons appris sur

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

Maintenant, nous pouvons utiliser un tableau 2D dans notre programme C,

Les références

Le crédit pour certaines idées dans ce travail a été inspiré par le cours, les pointeurs et les tableaux 2D, par Palash Dey Department of Computer Science & Engg. Institut indien de technologie Kharagpur

php

Comment utiliser la fonction strlen en php

La fonction strlen () en php est une fonction intégrée qui est utilisée pour calculer la longueur d'...

Ines Dubois

c Sharp

Comment utiliser le polymorphisme en C #

Le polymorphisme permet de traiter des objets de classes distinctes comme ils provenaient de la même...

Lena Martinez

C programmation C

Qu'est-ce que la gestion des fichiers dans la programmation C?

La gestion des fichiers est un aspect essentiel de la programmation C qui permet aux développeurs de...

Gabriel Bernard