2D niz

Dvodimenzionalni (2D) niz je niz jednodimenzionalnih (1D) nizova. Veličine 1D polja jednake su. 2D niz se naziva i matrica s redovima i stupcima.

Pogledajmo sljedeći primjer:

Ovi se 3D nizovi mogu prikazati kao 2D nizovi na sljedeći način:

Pogledajmo još jedan primjer:

Ovi 3D 1D nizovi ne mogu se predstavljati kao 2D nizovi jer su veličine nizova različite.

Deklaracija 2D niza

vrsta podataka ime polja[RED] [COL]

Vrsta podataka je vrsta podataka elemenata niza.
Array-name je ime niza.
Dva indeksa predstavljaju broj redaka i stupaca niza. Ukupan broj elemenata niza bit će ROW * COL.

int a [2] [3];

Koristeći gornji C kod, možemo proglasiti cijeli broj niz, a veličine 2 * 3 (2 reda i 3 stupca).

char b [3] [2];

Koristeći gornji C kod, možemo proglasiti a lik niz, b veličine 2 * 3 (3 reda i 2 stupca).

Inicijalizacija 2D niza

Tijekom deklaracije možemo se inicijalizirati na sljedeće načine:

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;

Imajte na umu da u 2 i 4 nismo spomenuli 1^sv indeks. Kompajler C automatski izračunava broj redaka iz broja elemenata. Ali 2^nd mora biti naveden indeks. Sljedeće inicijalizacije su nevaljane:

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

// Primjer1.c
#include
#define ROW 3
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Elementi niza a su: \ n");
za (i = 0; i
printf ("Red% d:", i);
za (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ n Elementi niza a u stupcima su: \ n");
za (i = 0; i
printf ("Stupac% d:", i);
za (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

return 0;

U Primjeru1.c, proglasili smo cjelobrojni niz veličine 3 * 2 i inicijalizirali. Za pristup elementima niza koristimo dva for petlje.

Da biste pristupili redom, vanjska petlja je za retke, a unutarnja za stupce.

Za pristup stupcima, vanjska petlja je za stupce, a unutarnja petlja za retke.

Imajte na umu da kada deklariramo 2D niz, koristimo [2] [3], što znači 2 retka i 3 stupca. Indeksiranje niza započinje od 0. Za pristup 2^nd red i 3^rd stupac, moramo koristiti oznaku a [1] [2].

Mapiranje memorije 2D niza

Logičan prikaz niza a [3] [2] može biti kako slijedi:

Računalna memorija je 1D slijed bajtova. Na jeziku C, 2D niz pohraniti u memoriju u red-dur red. Neki drugi programski jezici (npr.g., FORTRAN), pohranjuje u stupac-glavni red u sjećanju.

Aritmetika pokazivača 2D niza

Da biste razumjeli aritmetiku pokazivača 2D niza, prvo pogledajte 1D niz.

Razmotrimo 1D niz:

U 1D nizu, a je konstanta, a vrijednost joj je adresa 0^th mjesto niza a [5]. Vrijednost a + 1 je adresa 1^sv mjesto niza a [5]. a + i je adresa ja^th mjesto niza.

Ako povećamo a za 1, uvećava se za veličinu tipa podataka.

a [1] je ekvivalentan * (a + 1)

a [2] je ekvivalentan * (a + 2)

a [i] je ekvivalentan * (a + i)

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

// Primjer2.c
#include
#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));
return 0;

U Primjeru2.c, adresa memorije prikazuje se u heksadecimalnom obliku. Razlika između a i a + 1 je 4, što je veličina cijelog broja u bajtovima.

Sada razmotrite 2D niz:

b je pokazivač tipa: int [] [4] ili int (*) [4]

int [] [4] je red od 4 cjelobrojne vrijednosti. Ako b povećamo za 1, on se uvećava za veličinu retka.

b je adresa 0^th red.

b + 1 je adresa 1^sv red.

b + i je adresa ja^th red.

Veličina reda je: (Broj bajtova * veličina stupca * (vrsta podataka))

Veličina reda cjelobrojnog niza b [3] [4] je: 4 * veličina (int) = 4 * 4 = 16 bajtova

Red 2D niza može se promatrati kao 1D niz. b je adresa 0^th red. Dakle, dobili smo sljedeće

* b + 1 je adresa 1^sv element 0^th
* b + j je adresa j^th element 0^th
* (b + i) je adresa 0^th element ja^th
* (b + i) + j je adresa j^th element ja^th
b [0] [0] ekvivalentno je ** b
b [0] [1] ekvivalentno je * (* b + 1)
b [1] [0] ekvivalentno je * (* (b + 1))
b [1] [1] ekvivalentan je * (* (b + 1) +1)
b [i] [j] ekvivalentno je * (* (b + i) + j)

Adresa b [i] [j]: b + veličina (vrsta podataka) * (Broj stupca * i + j)

Razmotrimo 2D niz: int b [3] [4]

Adresa b [2] [1] je : b + veličina (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

// Primjer3.c
#include
#define ROW 3
#define COL 4
int main ()

int i, j;
int b [RED] [COL] =
10,20,30,40,
50,60,70,80,
90.100.110.120
;
printf ("sizeof (int):% ld \ n", sizeof (int));
printf ("Veličina reda:% 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) );
return 0;

U Primjeru3.c, vidjeli smo da je veličina retka 16 u decimalnom zapisu. Razlika između b + 1 i b je 10 u heksadecimalnom. 10 u heksadecimalnom ekvivalentu je 16 u decimalnom.

Zaključak

Dakle, u ovom smo članku saznali više o tome

Deklaracija 2D niza
Inicijalizacija 2D niza
Mapiranje memorije 2D niza
Aritmetika pokazivača 2D niza

Sada bez ikakve sumnje možemo koristiti 2D niz u našem C programu,

Reference

Zasluge za neke ideje u ovom radu inspirirane su tečajem, Pokazatelji i 2-D nizovi, Palash Dey, Odjel za računalne znanosti i Engg. Indijski tehnološki institut Kharagpur