2D massiiv

Kahemõõtmeline (2D) massiiv on ühemõõtmeliste (1D) massiivide massiiv. 1D massiivi suurused on võrdsed. 2D massiivi nimetatakse ka ridade ja veergudega maatriksiks.

Vaatame järgmist näidet:

Neid 3 1D massiivi saab kujutada 2D massiivina järgmiselt:

Vaatame veel ühte näidet:

Need 3 1D massiivi ei saa kujutada 2D massiivina, kuna massiivide suurused on erinevad.

2D massiivi deklaratsioon

andmetüüp massiivi nimi[RIDA] [COL]

Andmetüüp on massiivi elementide andmetüüp.
Massiivi nimi on massiivi nimi.
Kaks tellimust tähistavad massiivi ridade ja veergude arvu. Massiivi elementide koguarv on ROW * COL.

int a [2] [3];

Kasutades ülaltoodud C-koodi, võime deklareerida täisarv massiiv, a suurusest 2 * 3 (2 rida ja 3 veergu).

char b [3] [2];

Kasutades ülaltoodud C-koodi, võime deklareerida a iseloomu massiiv, b suurusest 2 * 3 (3 rida ja 2 veergu).

2D massiivi initsialiseerimine

Deklaratsiooni vormistamise ajal saame lähtestada järgmistel viisidel:

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;

Pange tähele, et punktides 2 ja 4 ei ole me ühte maininud^st alaindeks. C kompilaator arvutab elementide arvust automaatselt ridade arvu. Kuid 2^nd alapunkt tuleb täpsustada. Järgmised lähtestamised on valed:

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

// Näide1.c
# kaasata
#define 3. RIDA
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Massiivi a reaelemendid on: \ n");
jaoks (i = 0; i
printf ("Rida% d:", i);
jaoks (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nMassiivi a veerutark elemendid on: \ n");
jaoks (i = 0; i
printf ("veerg% d:", i);
jaoks (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

tagastama 0;

Näites1.c, oleme deklareerinud täisarvu massiivi suurusega 3 * 2 ja lähtestanud. Massiivielementidele juurde pääsemiseks kasutame loopi jaoks kahte.

Ridade kaupa juurdepääsuks on välimine silmus ridade jaoks ja sisemine silmus veergude jaoks.

Veergude kaupa juurdepääsuks on väline silmus veergude jaoks ja sisemine silmus ridade jaoks.

Pange tähele, et kui deklareerime 2D massiivi, kasutame [2] [3], mis tähendab 2 rida ja 3 veergu. Massiivi indekseerimine algab 0-st. 2^nd rida ja 3^rd veerus peame kasutama märget a [1] [2].

2D massiivi mälukaardistamine

Massiivi loogiline vaade a [3] [2] võivad olla järgmised:

Arvutimälu on 1D baitide jada. C-keeles 2D massiivi pood mälus rida-suur järjekord. Mõned muud programmeerimiskeeled (nt.g., FORTRAN), see salvestub veerg-suurem järjekord mällu.

2D massiivi osuti aritmeetika

2D massiivi kursori aritmeetika mõistmiseks vaadake kõigepealt 1D massiivi.

Mõelge 1D massiivile:

1D massiivis, a on konstant ja selle väärtus on 0 aadress^th massiivi asukoht a [5]. Väärtus a + 1 on 1 aadressi aadress^st massiivi asukoht a [5]. a + i on ettevõtte aadress i^th massiivi asukoht.

Kui me suurendame a 1 võrra suurendab seda andmetüübi suurus.

a [1] on samaväärne * (a + 1)

a [2] on samaväärne * (a + 2)

a [i] on samaväärne * (a + i)

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

// Näide2.c
# kaasata
#define 3. RIDA
#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));
tagastama 0;

Näites2.c, kuvatakse mäluaadress kuueteistkümnendsüsteemis. Erinevus a ja a + 1 vahel on 4, mis on täisarv baitides.

Nüüd kaaluge 2D massiivi:

b on tüüpi tüüp: int [] [4] või int (*) [4]

int [] [4] on 4 täisarvu rida. Kui suurendame b võrra 1, suurendatakse seda rea suurusega.

b on ettevõtte aadress 0^th rida.

b + 1 on ettevõtte aadress 1^st rida.

b + i on aadressi aadress i^th rida.

Rea suurus on: (Veeru arv * sizeof (andmetüüp)) baiti

Täisarvu massiivi b [3] [4] rea suurus on: 4 * (int) suurus = 4 * 4 = 16 baiti

2D massiivi rida võib vaadelda kui 1D massiivi. b on ettevõtte aadress 0^th rida. Nii saame järgmise

* b + 1 on ettevõtte aadress 1^st element 0^th
* b + j on ettevõtte aadress j^th element 0^th
* (b + i) on ettevõtte aadress 0^th element i^th
* (b + i) + j on ettevõtte aadress j^th element i^th
b [0] [0] on samaväärne ** b-ga
b [0] [1] võrdub * (* b + 1)
b [1] [0] võrdub * (* (b + 1))
b [1] [1] võrdub * (* (b + 1) +1)
b [i] [j] on samaväärne * (* (b + i) + j)

B [i] [j] aadress: b + sizeof (andmetüüp) * (veeru arv * i + j)

Mõelge 2D massiivile: int b [3] [4]

B [2] [1] aadress on : b + (int) suurus * (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

Näide3.c
# kaasata
#define 3. RIDA
#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 ("Rea suurus:% 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) );
tagastama 0;

Näites3.c, oleme näinud, et rea suurus on kümnendkohtades 16. B + 1 ja b vahe on kuueteistkümnendsüsteemis 10. 10 kuueteistkümnendsüsteemis on võrdne 16 kümnendkohaga.

Järeldus

Nii et selles artiklis oleme õppinud

2D massiivi deklaratsioon
2D massiivi initsialiseerimine
2D massiivi mälukaardistamine
2D massiivi osuti aritmeetika

Nüüd saame oma C-programmis kahtlemata kasutada 2D massiivi,

Viited

Selle teose mõnede ideede au on inspireeritud kursusest "Näpunäited ja 2-D massiivid", mille autor on Palash Dey arvutiteaduse ja Enggi osakond. India tehnoloogiainstituut Kharagpur