2D-array

Een tweedimensionale (2D) array is een array van eendimensionale (1D) arrays. De afmetingen van de 1D-array zijn gelijk. De 2D-array wordt ook wel een matrix met rijen en kolommen genoemd.

Laten we het volgende voorbeeld bekijken:

Deze 3 1D-arrays kunnen als volgt worden weergegeven als een 2D-array:

Laten we nog een voorbeeld bekijken:

Deze 3 1D-arrays kunnen niet worden weergegeven als een 2D-array omdat de afmetingen van de arrays verschillend zijn.

Verklaring van 2D-array

data type arraynaam[RIJ][COL]

Data type is het gegevenstype van de array-elementen.
Array-naam is de naam van de array.
Twee subscripts vertegenwoordigen het aantal rijen en kolommen van de array. Het totale aantal elementen van de array is ROW*COL.

int a[2][3];

Met behulp van de bovenstaande C-code kunnen we een declareren geheel getal reeks, een van grootte 2*3 (2 rijen en 3 kolommen).

char b[3][2];

Met behulp van de bovenstaande C-code kunnen we a . declareren karakter reeks, b van grootte 2*3 (3 rijen en 2 kolommen).

Initialisatie van 2D-array

We kunnen op de volgende manieren initialiseren tijdens de aangifte:

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;

Merk op dat we in 2 en 4 de 1 . niet hebben genoemd^st abonnement. De C-compiler berekent automatisch het aantal rijen uit het aantal elementen. Maar de 2^nd subscript moet worden opgegeven. De volgende initialisaties zijn ongeldig:

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
10
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

//Voorbeeld 1.c
#include
#definieer RIJ 3
#define COL 2
int hoofd()

int i,j;
int a[RIJ][COL] =
1,2,
3,4,
5,6
;
printf("Rijgewijze elementen van de array a zijn :\n");
voor(i=0;i
printf("Rij %d:",i);
voor(j=0;j
printf(" %d",a[i][j]);

printf("\n");

printf("\n\nKolomgewijs Elementen van de array a zijn :\n");
voor(i=0;i
printf("Kolom %d:",i);
voor(j=0;j
printf(" %d",a[j][i]);

printf("\n");

retourneer 0;

In voorbeeld1.c, we hebben een integer-array van grootte 3*2 gedeclareerd en geïnitialiseerd. Om toegang te krijgen tot array-elementen, gebruiken we twee for loop.

Om rijgewijs toegang te krijgen, is de buitenste lus voor rijen en de binnenste lus voor kolommen.

Om kolomgewijs toegang te krijgen, is de buitenste lus voor kolommen en de binnenste lus voor rijen.

Merk op dat wanneer we een 2D-array declareren, we a[2][3] gebruiken, wat 2 rijen en 3 kolommen betekent. Matrix-indexering begint vanaf 0. Om toegang te krijgen tot de 2^nd rij en 3^rd kolom, moeten we de notatie a[1][2] gebruiken.

Geheugentoewijzing van een 2D-array

De logische weergave van een array een[3][2] kan als volgt zijn:

Computergeheugen is een 1D-reeks van bytes. In C-taal slaat een 2D-array op in het geheugen in rij-grote volgorde. Enkele andere programmeertalen (e.g., FORTRAN), het slaat op in kolom-hoofdvolgorde in het geheugen.

Aanwijzer rekenkunde van een 2D-array

Om de aanwijzerberekening van de 2D-array te begrijpen, kijk eerst naar de 1D-array.

Overweeg een 1D-array:

In 1D-array, een is een constante, en de waarde ervan is het adres van de 0^dit locatie van de array een[5]. Waarde van een+1 is het adres van de 1^st locatie van de array een[5]. a+i is het adres van de ik^dit locatie van de array.

Als we verhogen een met 1, het wordt verhoogd met de grootte van het gegevenstype.

een[1] is gelijk aan *(een+1)

een[2] is gelijk aan *(a+2)

een[ik] is gelijk aan *(a+ik)

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

//Voorbeeld2.c
#include
#definieer RIJ 3
#define COL 2
int hoofd()

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));
retourneer 0;

In voorbeeld2.c, het geheugenadres wordt in hexadecimaal weergegeven. Het verschil tussen a en a+1 is 4, wat de grootte is van een geheel getal in bytes.

Overweeg nu een 2D-array:

b is een aanwijzer van het type: int[ ][4] of int(*)[4]

int[ ][4] is een rij van 4 integer. Als we b met 1 verhogen, wordt deze verhoogd met de grootte van de rij.

b is het adres van de 0^dit rij.

b+1 is het adres van de 1^st rij.

b+i is het adres van ik^dit rij.

De grootte van een rij is: ( Aantal kolommen * sizeof(data-type)) bytes

Grootte van een rij van een integer array b[3][4] is: 4 * sizeof(int) = 4 * 4 = 16 bytes

Een rij van een 2D-array kan worden gezien als een 1D-array. b is het adres van de 0^dit rij. Dus we krijgen het volgende:

*b+1 is het adres van de 1^st onderdeel van de 0^dit
*b+j is het adres van de j^dit onderdeel van de 0^dit
*(b+ik) is het adres van de 0^dit onderdeel van de ik^dit
*(b+i)+j is het adres van de j^dit element van de ik^dit
b[0][0] is gelijk aan **b
b[0][1] is gelijk aan *(*b+1)
b[1][0] is gelijk aan *(*(b+1))
b[1][1] is gelijk aan *(*(b+1)+1)
b[i][j] is gelijk aan *(*(b+i)+j)

Adres van b[i][j]: b + sizeof(data-type) * ( Aantal kolommen * i + j)

Overweeg een 2D-array: int b[3] [4]

Adres van b[2][1] is : b + groottevan(int) * (4*2 + 1)

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

//Voorbeeld3.c
#include
#definieer RIJ 3
#define COL 4
int hoofd()

int i,j;
int b[RIJ][COL] =
10,20,30,40,
50,60,70,80,
90,100,110,120
;
printf("sizeof(int): %ld\n",sizeof(int));
printf("Grootte van een rij: %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) );
retourneer 0;

In voorbeeld3.c, we hebben gezien dat de grootte van een rij 16 is in decimale notatie. Het verschil tussen b+1 en b is 10 in hexadecimaal. 10 in hexadecimaal is gelijk aan 16 in decimaal.

Conclusie

Dus in dit artikel hebben we geleerd over:

Verklaring van 2D-array
Initialisatie van 2D-array
Geheugentoewijzing van 2D-array
Aanwijzer rekenkunde van 2D-array

Nu kunnen we zonder enige twijfel 2D-array in ons C-programma gebruiken,

Referenties

Krediet voor sommige ideeën in dit werk werden geïnspireerd door de cursus, Pointers and 2-D Arrays, door Palash Dey Department of Computer Science & Engg. Indian Institute of Technology Kharagpur