2D Array

En tvådimensionell (2D) array är en array med endimensionella (1D) matriser. 1D-gruppstorlekarna är lika. 2D-arrayen kallas också en matris med rader och kolumner.

Låt oss se följande exempel:

Dessa 3 1D-arrayer kan representeras som en 2D-array enligt följande:

Låt oss se ett annat exempel:

Dessa 3 1D-matriser kan inte representeras som en 2D-matris eftersom storleken på matriserna är olika.

Förklaring om 2D-array

data typ array-namn[RAD] [COL]

Data typ är datatypen för arrayelementen.
Array-name är namnet på arrayen.
Två prenumerationer representerar antalet rader och kolumner i matrisen. Det totala antalet element i matrisen kommer att vara ROW * COL.

int a [2] [3];

Med hjälp av ovanstående C-kod kan vi deklarera en heltal array, a av storlek 2 * 3 (2 rader och 3 kolumner).

char b [3] [2];

Med hjälp av ovanstående C-kod kan vi förklara a karaktär array, b av storlek 2 * 3 (3 rader och 2 kolumner).

Initialisering av 2D-array

Vi kan initialisera under deklarationen på följande sätt:

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;

Observera att i 2 och 4 har vi inte nämnt 1^st index. C-kompilatorn beräknar automatiskt antalet rader från antalet element. Men 2^nd prenumeration måste anges. Följande initialiseringar är ogiltiga:

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

// Exempel1.c
#omfatta
#define ROW 3
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Radvisa element i arrayen a är: \ n");
för (i = 0; i
printf ("Rad% d:", i);
för (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nKolumnvisa element i arrayen a är: \ n");
för (i = 0; i
printf ("Kolumn% d:", i);
för (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

returnera 0;

I exempel 1.c, vi har deklarerat en heltalsserie av storlek 3 * 2 och initialiserats. För att komma åt arrayelement använder vi två för loop.

För att komma åt rad är den yttre slingan för rader och den inre slingan för kolumner.

För att komma åt kolumnmässigt är den yttre slingan för kolumner och den inre slingan är för rader.

Observera att när vi deklarerar en 2D-array använder vi en [2] [3], vilket betyder två rader och 3 kolumner. Matrisindexering börjar från 0. För att komma åt 2^nd rad och 3^rd kolumn måste vi använda notationen a [1] [2].

Minnesmappning av en 2D-array

Den logiska vyn för en matris a [3] [2] kan vara följande:

Datorminne är en 1D-sekvens av byte. I C-språk lagras en 2D-array i minnet i rad-major order. Några andra programmeringsspråk (t.ex.g., FORTRAN), lagras det i kolumn-major order i minnet.

Pointer Arithmetic of a 2D array

För att förstå pekarens aritmetik för 2D-matrisen, ta en titt på 1D-matrisen.

Tänk på en 1D-array:

I 1D-array, a är en konstant, och dess värde är adressen till 0^th plats för matrisen a [5]. Värdet av a + 1 är adressen till 1^st plats för matrisen a [5]. a + i är adressen till i^th plats för matrisen.

Om vi ökar a med 1 ökas den av datatypens storlek.

a [1] är ekvivalent med * (a + 1)

a [2] är ekvivalent med * (a + 2)

a [i] är ekvivalent med * (a + i)

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

// Exempel2.c
#omfatta
#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));
returnera 0;

I exempel 2.c, minnesadressen visas i hexadecimal. Skillnaden mellan a och a + 1 är 4, vilket är storleken på ett heltal i byte.

Tänk nu på en 2D-array:

b är en pekare av typen: int [] [4] eller int (*) [4]

int [] [4] är en rad med fyra heltal. Om vi ökar b med 1, ökas det med storleken på raden.

b är adressen till 0^th rad.

b + 1 är adressen till 1^st rad.

b + i är adressen till i^th rad.

Storleken på en rad är: (Antal kolumn * storlek på (datatyp)) byte

Storleken på en rad i ett heltal array b [3] [4] är: 4 * sizeof (int) = 4 * 4 = 16 byte

En rad i en 2D-grupp kan ses som en 1D-grupp. b är adressen till 0^th rad. Så vi får följande

* b + 1 är adressen till 1^st element i 0^th
* b + j är adressen till j^th element i 0^th
* (b + i) är adressen till 0^th element i i^th
* (b + i) + j är adressen till j^th element i i^th
b [0] [0] motsvarar ** b
b [0] [1] motsvarar * (* b + 1)
b [1] [0] motsvarar * (* (b + 1))
b [1] [1] motsvarar * (* (b + 1) +1)
b [i] [j] motsvarar * (* (b + i) + j)

Adress till b [i] [j]: b + storlek på (datatyp) * (Antal kolumner * i + j)

Tänk på en 2D-array: int b [3] [4]

Adress till b [2] [1] är : b + storlek på (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

// Exempel3.c
#omfatta
#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 ("Storlek på en rad:% 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) );
returnera 0;

I exempel 3.c, vi har sett att storleken på en rad är 16 i decimalnotation. Skillnaden mellan b + 1 och b är 10 i hexadecimal. 10 i hexadecimal motsvarar 16 i decimal.

Slutsats

Så i den här artikeln har vi lärt oss om

Förklaring om 2D-array
Initiering av 2D-array
Minnesmappning av 2D-array
Pointer Arithmetic of 2D array

Nu kan vi använda 2D-array i vårt C-program utan tvekan,

Referenser

Kredit för några idéer i detta arbete inspirerades av kursen Pointers and 2-D Arrays, av Palash Dey Department of Computer Science & Engg. Indian Institute of Technology Kharagpur