2D Array

En todimensjonal (2D) matrise er en matrise med endimensjonale (1D) matriser. 1D-arraystørrelsene er like. 2D-matrisen kalles også en matrise med rader og kolonner.

La oss se følgende eksempel:

Disse 3 1D-matriser kan vises som en 2D-matrise som følger:

La oss se et annet eksempel:

Disse 3 1D-matriser kan ikke representere som en 2D-matrise fordi størrelsen på matriser er forskjellige.

Erklæring om 2D-array

data-type array-name[RAD] [COL]

Data-type er datatypen til matriseelementene.
Array-name er navnet på matrisen.
To abonnementer representerer antall rader og kolonner i matrisen. Totalt antall elementer i matrisen vil være ROW * COL.

int a [2] [3];

Ved å bruke ovennevnte C-kode kan vi erklære en heltall array, en av størrelse 2 * 3 (2 rader og 3 kolonner).

char b [3] [2];

Ved hjelp av C-koden ovenfor kan vi erklære a karakter array, b av størrelse 2 * 3 (3 rader og 2 kolonner).

Initialisering av 2D-array

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

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 at vi i 2 og 4 ikke har nevnt 1^St abonnement. C-kompilatoren beregner automatisk antall rader fra antall elementer. Men 2^nd abonnement må spesifiseres. 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
1. 3
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
#inkludere
#define ROW 3
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Radvise elementer i matrisen a er: \ n");
for (i = 0; i
printf ("Rad% d:", i);
for (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

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

printf ("\ n");

retur 0;

I eksempel 1.c, vi har erklært et heltall matrise av størrelse 3 * 2 og initialisert. For å få tilgang til matriseelementer bruker vi to for loop.

For å få tilgang radmessig, er den ytre sløyfen for rader, og den indre sløyfen er for kolonner.

For å få tilgang til kolonnemessig er den ytre sløyfen for kolonner, og den indre sløyfen er for rader.

Merk at når vi erklærer en 2D-matrise, bruker vi en [2] [3], som betyr to rader og 3 kolonner. Arrayindeksering starter fra 0. For å få tilgang til 2^nd rad og 3^rd kolonne, må vi bruke notasjonen a [1] [2].

Minnekartlegging av et 2D-utvalg

Den logiske visningen av en matrise a [3] [2] kan være som følger:

Dataminne er en 1D sekvens av byte. På C-språk lagres et 2D-array i minnet i rekke-ordre. Noen andre programmeringsspråk (f.eks.g., FORTRAN), lagrer den i kolonne-stor ordre i minnet.

Pointer Arithmetic of a 2D array

For å forstå pekeraritmetikken til 2D-matrisen, ta først en titt på 1D-matrisen.

Tenk på et 1D-utvalg:

I 1D-array, en er en konstant, og verdien er adressen til 0^th plasseringen av matrisen a [5]. Verdien av a + 1 er adressen til 1^St plasseringen av matrisen a [5]. a + i er adressen til Jeg^th plasseringen av matrisen.

Hvis vi øker en med 1, økes den av størrelsen på datatypen.

a [1] tilsvarer * (a + 1)

a [2] tilsvarer * (a + 2)

a [i] tilsvarer * (a + i)

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

// Eksempel2.c
#inkludere
#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));
retur 0;

I eksempel 2.c, minneadressen vises i heksadesimal. Forskjellen mellom a og a + 1 er 4, som er størrelsen på et heltall i byte.

Vurder nå et 2D-utvalg:

b er en peker av typen: int [] [4] eller int (*) [4]

int [] [4] er en rad med 4 heltall. Hvis vi øker b med 1, økes det av størrelsen på raden.

b er adressen til 0^th rad.

b + 1 er adressen til 1^St rad.

b + i er adressen til Jeg^th rad.

Størrelsen på en rad er: (Antall kolonne * størrelse på (datatype)) byte

Størrelsen på en rad i et heltall array b [3] [4] er: 4 * sizeof (int) = 4 * 4 = 16 byte

En rad med en 2D-array kan sees på som en 1D-array. b er adressen til 0^th rad. Så vi får følgende

* b + 1 er adressen til 1^St element av 0^th
* b + j er adressen til j^th element av 0^th
* (b + i) er adressen til 0^th element av Jeg^th
* (b + i) + j er adressen til j^th element av Jeg^th
b [0] [0] tilsvarer ** b
b [0] [1] tilsvarer * (* b + 1)
b [1] [0] tilsvarer * (* (b + 1))
b [1] [1] tilsvarer * (* (b + 1) +1)
b [i] [j] tilsvarer * (* (b + i) + j)

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

Vurder et 2D-utvalg: int b [3] [4]

Adressen til b [2] [1] er : b + størrelse på (int) * (4 * 2 + 1)

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

// Eksempel3.c
#inkludere
#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 ("Størrelse 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) );
retur 0;

I eksempel 3.c, vi har sett at størrelsen på en rad er 16 i desimalnotasjon. Forskjellen mellom b + 1 og b er 10 i heksadesimal. 10 i heksadesimal tilsvarer 16 i desimal.

Konklusjon

Så i denne artikkelen har vi lært om

Erklæring om 2D-array
Initialisering av 2D-array
Minnekartlegging av 2D-array
Pointer Arithmetic of 2D array

Nå kan vi bruke 2D-array i C-programmet vårt uten tvil,

Referanser

Kreditt for noen ideer i dette arbeidet er inspirert av kurset Pointers and 2-D Arrays, av Palash Dey Department of Computer Science & Engg. Indian Institute of Technology Kharagpur