2D masyvas

Dvimatis (2D) masyvas yra vienos dimensijos (1D) masyvų masyvas. 1D masyvo dydžiai yra vienodi. 2D masyvas taip pat vadinamas matrica su eilutėmis ir stulpeliais.

Pažiūrėkime šį pavyzdį:

Šie 3 1D masyvai gali būti vaizduojami kaip 2D masyvai taip:

Pažiūrėkime dar vieną pavyzdį:

Šie 3 1D masyvai negali būti vaizduojami kaip 2D masyvai, nes masyvų dydžiai yra skirtingi.

2D masyvo deklaracija

duomenų tipas masyvo pavadinimas[EILĖ] [COL]

Duomenų tipas yra masyvo elementų duomenų tipas.
Masyvo vardas yra masyvo pavadinimas.
Du prenumeratos nurodo masyvo eilučių ir stulpelių skaičių. Bendras masyvo elementų skaičius bus ROW * COL.

int a [2] [3];

Naudodami pirmiau nurodytą C kodą, galime deklaruoti sveikasis skaičius masyvas, a dydžio 2 * 3 (2 eilutės ir 3 stulpeliai).

char b [3] [2];

Naudodami minėtą C kodą, galime deklaruoti a charakteris masyvas, b dydžio 2 * 3 (3 eilutės ir 2 stulpeliai).

2D masyvo inicijavimas

Deklaravimo metu galime inicijuoti šiais būdais:

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;

Atkreipkite dėmesį, kad 2 ir 4 dalyse mes neminėjome 1^šv stenograma. C kompiliatorius automatiškai apskaičiuoja eilučių skaičių iš elementų skaičiaus. Tačiau 2^nd turi būti nurodytas indeksas. Šie inicialai yra neteisingi:

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

// 1 pavyzdys.c
# įtraukti
#define 3 EILĖ
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Eilutės masyvo a elementai yra: \ n");
už (i = 0; i
printf ("% d eilutė:", i);
už (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nTinkliniai a masyvo elementai yra: \ n");
už (i = 0; i
printf ("% d stulpelis:", i);
už (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

grąžinti 0;

1 pavyzdyje.c, mes paskelbėme sveiko skaičiaus masyvą, kurio dydis 3 * 2, ir inicializavome. Norėdami pasiekti masyvo elementus, mes naudojame du ciklui.

Norint pasiekti eilutes, išorinė kilpa skirta eilutėms, o vidinė - stulpeliams.

Norėdami pasiekti stulpelius, išorinė kilpa skirta stulpeliams, o vidinė - eilutėms.

Atkreipkite dėmesį, kad kai deklaruojame 2D masyvą, mes naudojame [2] [3], o tai reiškia 2 eilutes ir 3 stulpelius. Masyvo indeksavimas prasideda nuo 0. Norėdami pasiekti 2^nd eilutė ir 3^rd stulpelį, turime naudoti žymėjimą a [1] [2].

2D masyvo atminties atvaizdavimas

Loginis masyvo vaizdas a [3] [2] gali būti tokie:

Kompiuterio atmintis yra 1D baitų seka. C kalba, 2D masyvų saugykla atmintyje eilės-pagrindinės eilės tvarka. Kai kurios kitos programavimo kalbos (pvz.,.g., FORTRAN), jis saugomas stulpelis-pagrindinis įsakymas atmintyje.

2D matricos žymeklis aritmetika

Norėdami suprasti 2D masyvo rodyklės aritmetiką, pirmiausia pažvelkite į 1D masyvą.

Apsvarstykite 1D masyvą:

1D masyvu, a yra konstanta, o jos vertė yra 0 adresas^tūkst masyvo vieta a [5]. Vertė a + 1 yra 1 adresas^šv masyvo vieta a [5]. a + i yra adresas i^tūkst masyvo vieta.

Jei mes padidinsime a 1, tai padidinama pagal duomenų tipo dydį.

a [1] yra lygiavertis * (a + 1)

a [2] yra lygiavertis * (a + 2)

a [i] yra lygiavertis * (a + i)

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

// 2 pavyzdys.c
# įtraukti
#define 3 EILĖ
#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));
grąžinti 0;

2 pavyzdyje.c, atminties adresas rodomas šešioliktainiais skaičiais. Skirtumas tarp a ir a + 1 yra 4, tai yra sveiko skaičiaus dydis baitais.

Dabar apsvarstykite 2D masyvą:

b yra tipo rodyklė: int [] [4] arba int (*) [4]

int [] [4] yra 4 sveikųjų skaičių eilutė. Jei b padidinsime 1, tai padidės pagal eilutės dydį.

b yra adresas 0^tūkst eilutė.

b + 1 yra adresas 1^šv eilutė.

b + i yra adresas i^tūkst eilutė.

Eilutės dydis yra: (Stulpelio skaičius * dydis (duomenų tipas)) baitų

Sveiko skaičiaus masyvo b [3] [4] eilutės dydis yra: 4 * (int) dydis = 4 * 4 = 16 baitų

2D masyvo eilutė gali būti vertinama kaip 1D masyvas. b yra adresas 0^tūkst eilutė. Taigi, gauname taip

* b + 1 yra adresas 1^šv elementas 0^tūkst
* b + j yra adresas j^tūkst elementas 0^tūkst
* (b + i) yra adresas 0^tūkst elementas i^tūkst
* (b + i) + j yra adresas j^tūkst elementas i^tūkst
b [0] [0] atitinka ** b
b [0] [1] atitinka * (* b + 1)
b [1] [0] atitinka * (* (b + 1))
b [1] [1] atitinka * (* (b + 1) +1)
b [i] [j] yra lygiavertis * (* (b + i) + j)

B [i] [j] adresas: b + sizeof (duomenų tipas) * (stulpelio skaičius * i + j)

Apsvarstykite 2D masyvą: int b [3] [4]

B [2] [1] adresas yra : b + dydis (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

// 3 pavyzdys.c
# įtraukti
#define 3 EILĖ
#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 ("Eilutės dydis:% 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) );
grąžinti 0;

3 pavyzdyje.c, mes matėme, kad eilutės dydis yra dešimtainis ženklas. Skirtumas tarp b + 1 ir b yra 10 šešioliktainiu skaičiumi. 10 šešioliktainiu skaičiumi atitinka 16 po kablelio.

Išvada

Taigi, šiame straipsnyje mes sužinojome apie

2D masyvo deklaracija
2D masyvo inicijavimas
2D masyvo atminties atvaizdavimas
2D matricos žymeklis aritmetika

Dabar be jokių abejonių galime naudoti 2D masyvą savo C programoje,

Literatūra

Kreditą už kai kurias šio darbo idėjas įkvėpė kursas „Rodyklės ir 2-D masyvai“, kurį sukūrė Palasho Dey Kompiuterijos ir anglų kalbos katedra. Indijos technologijos institutas Kharagpur