2D Array

Et todimensionalt (2D) array er et array med et dimensionelt (1D) arrays. 1D-arraystørrelserne er ens. 2D-arrayet kaldes også en matrix med rækker og kolonner.

Lad os se følgende eksempel:

Disse 3 1D-arrays kan repræsenteres som et 2D-array som følger:

Lad os se et andet eksempel:

Disse 3 1D-arrays kan ikke repræsenteres som et 2D-array, fordi størrelserne på arrays er forskellige.

Erklæring om 2D-array

datatype array-navn[RÆKKE] [COL]

Datatype er datatypen for matrixelementerne.
Array-name er arrayets navn.
To abonnementer repræsenterer antallet af rækker og kolonner i arrayet. Det samlede antal elementer i arrayet er ROW * COL.

int a [2] [3];

Ved hjælp af ovenstående C-kode kan vi erklære en heltal array, -en af størrelse 2 * 3 (2 rækker og 3 kolonner).

char b [3] [2];

Ved hjælp af ovenstående C-kode kan vi erklære en Karakter array, b af størrelse 2 * 3 (3 rækker og 2 kolonner).

Initialisering af 2D-array

Vi kan initialisere under erklæringen på følgende måder:

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;

Bemærk, at vi i 2 og 4 ikke har nævnt 1^St abonnement. C-kompilatoren beregner automatisk antallet af rækker ud fra antallet af elementer. Men 2^nd abonnement skal specificeres. Følgende initialiseringer er ugyldige:

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

// Eksempel1.c
#omfatte
#definer Række 3
#definer COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Rækkevise elementer i array a er: \ n");
for (i = 0; i
printf ("Række% d:", i);
for (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nKolonnevise elementer i arrayet a er: \ n");
for (i = 0; i
printf ("Kolonne% d:", i);
for (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

returnere 0;

I eksempel 1.c, vi har deklareret et heltal array af størrelse 3 * 2 og initialiseret. For at få adgang til arrayelementer bruger vi to til loop.

For at få adgang til rækkevidde er den ydre sløjfe for rækker, og den indre sløjfe er for kolonner.

For at få adgang til kolonnemæssigt er den ydre sløjfe for kolonner, og den indre sløjfe er for rækker.

Bemærk, at når vi erklærer et 2D-array, bruger vi en [2] [3], hvilket betyder 2 rækker og 3 kolonner. Arrayindeksering starter fra 0. For at få adgang til 2^nd række og 3^rd kolonne, skal vi bruge notationen a [1] [2].

Hukommelseskortlægning af et 2D-array

Den logiske visning af en matrix a [3] [2] kan være som følger:

Computerhukommelse er en 1D sekvens af bytes. På C-sprog gemmes et 2D-array i hukommelsen i række-ordre. Nogle andre programmeringssprog (f.eks.g., FORTRAN), gemmer den i kolonne-større ordre i hukommelsen.

Pointer Arithmetic of a 2D array

For at forstå pointeraritmetikken i 2D-arrayet skal du først se på 1D-arrayet.

Overvej et 1D-array:

I 1D-array, -en er en konstant, og dens værdi er adressen på 0^th placeringen af arrayet a [5]. Værdi af a + 1 er adressen på 1^St placeringen af arrayet a [5]. a + i er adressen på jeg^th placeringen af arrayet.

Hvis vi øger -en med 1 øges den af datatypens størrelse.

a [1] svarer til * (a + 1)

a [2] svarer til * (a + 2)

a [i] svarer til * (a + i)

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

// Eksempel2.c
#omfatte
#definer Række 3
#definer 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));
returnere 0;

I eksempel 2.c, hukommelsesadressen vises i hexadecimal. Forskellen mellem a og a + 1 er 4, hvilket er størrelsen på et heltal i byte.

Overvej nu et 2D-array:

b er en markør af typen: int [] [4] eller int (*) [4]

int [] [4] er en række med 4 heltal. Hvis vi forøger b med 1, øges det af størrelsen på rækken.

b er adressen på 0^th række.

b + 1 er adressen på 1^St række.

b + i er adressen på jeg^th række.

Størrelsen på en række er: (Antal kolonne * størrelse af (datatype)) byte

Størrelsen på en række af et heltal array b [3] [4] er: 4 * sizeof (int) = 4 * 4 = 16 bytes

En række af et 2D-array kan ses som et 1D-array. b er adressen på 0^th række. Så vi får følgende

* b + 1 er adressen på 1^St element i 0^th
* b + j er adressen på j^th element i 0^th
* (b + i) er adressen på 0^th element i jeg^th
* (b + i) + j er adressen på j^th element i jeg^th
b [0] [0] svarer til ** b
b [0] [1] svarer til * (* b + 1)
b [1] [0] svarer til * (* (b + 1))
b [1] [1] svarer til * (* (b + 1) +1)
b [i] [j] svarer til * (* (b + i) + j)

Adresse på b [i] [j]: b + størrelse af (datatype) * (Antal kolonner * i + j)

Overvej et 2D-array: int b [3] [4]

Adresse på b [2] [1] er : b + størrelse af (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

// Eksempel3.c
#omfatte
#definer Række 3
#definer 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 ("Størrelse på en række:% 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) );
returnere 0;

I eksempel 3.c, vi har set, at størrelsen på en række er 16 i decimalnotation. Forskellen mellem b + 1 og b er 10 i hexadecimal. 10 i hexadecimal svarer til 16 i decimal.

Konklusion

Så i denne artikel har vi lært om

Erklæring om 2D-array
Initialisering af 2D-array
Hukommelseskortlægning af 2D-array
Pointer Arithmetic of 2D array

Nu kan vi uden tvivl bruge 2D-array i vores C-program,

Referencer

Kredit for nogle ideer i dette arbejde blev inspireret af kurset, Pointers and 2-D Arrays, af Palash Dey Department of Computer Science & Engg. Indian Institute of Technology Kharagpur