2D masīvs

Divdimensiju (2D) masīvs ir vienas dimensijas (1D) masīvu masīvs. 1D masīva izmēri ir vienādi. 2D masīvu sauc arī par matricu ar rindām un kolonnām.

Apskatīsim šādu piemēru:

Šos 3 1D masīvus var attēlot kā 2D masīvus šādi:

Apskatīsim vēl vienu piemēru:

Šie 3 1D masīvi nevar attēlot kā 2D masīvu, jo masīvu izmēri ir atšķirīgi.

2D masīva deklarācija

datu tips masīva nosaukums[RINDA] [COL]

Datu tips ir masīva elementu datu tips.
Masīva nosaukums ir masīva nosaukums.
Divi abonenti norāda masīva rindu un kolonnu skaitu. Masīva elementu kopējais skaits būs ROW * COL.

int a [2] [3];

Izmantojot iepriekš minēto C kodu, mēs varam deklarēt vesels skaitlis masīvs, a lieluma 2 * 3 (2 rindas un 3 kolonnas).

char b [3] [2];

Izmantojot iepriekš minēto C kodu, mēs varam deklarēt a raksturs masīvs, b lieluma 2 * 3 (3 rindas un 2 kolonnas).

2D masīva inicializēšana

Deklarēšanas laikā mēs varam inicializēt šādos veidos:

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;

Ņemiet vērā, ka 2. un 4. pantā mēs neesam pieminējuši 1^sv apakšindekss. C kompilators automātiski aprēķina rindu skaitu no elementu skaita. Bet 2^nd apakšindekss ir jānorāda. Šīs inicializācijas nav derīgas:

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

// Piemērs1.c
# iekļaut
#define 3. rinda
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Masīva a rindas elementi ir: \ n");
par (i = 0; i
printf ("% d. rinda:", i);
par (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nKolonnu masīva a elementi ir: \ n");
par (i = 0; i
printf ("Kolonna% d:", i);
par (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

atgriešanās 0;

1. piemērā.c, mēs esam deklarējuši vesela skaitļa masīvu 3 * 2 un inicializējuši. Lai piekļūtu masīva elementiem, mēs izmantojam divus cilpa.

Lai piekļūtu rindām, ārējā cilpa ir paredzēta rindām, bet iekšējā - kolonnām.

Lai piekļūtu kolonnām, ārējā cilpa ir paredzēta kolonnām, bet iekšējā - rindām.

Ņemiet vērā, ka, deklarējot 2D masīvu, mēs izmantojam [2] [3], kas nozīmē 2 rindas un 3 kolonnas. Masīva indeksēšana sākas no 0. Lai piekļūtu 2^nd rinda un 3^rd kolonnā, mums jāizmanto apzīmējums a [1] [2].

2D masīva atmiņas kartēšana

Masīva loģiskais skats a [3] [2] var būt šādi:

Datora atmiņa ir 1D baitu secība. C valodā 2D masīvu veikals atmiņā rindu-galveno kārtība. Dažas citas programmēšanas valodas (piemēram,.g., FORTRAN), tas tiek uzglabāts kolonna-galvenais pasūtījums atmiņā.

2D masīva rādītāja aritmētika

Lai saprastu 2D masīva rādītāju aritmētiku, vispirms ieskatieties 1D masīvā.

Apsveriet 1D masīvu:

1D masīvā, a ir konstante, un tā vērtība ir 0 adrese^th masīva atrašanās vieta a [5]. Vērtība a + 1 ir adreses 1^sv masīva atrašanās vieta a [5]. a + i ir uzņēmuma adrese i^th masīva atrašanās vieta.

Ja mēs palielinām a par 1, to palielina pēc datu veida lieluma.

a [1] ir ekvivalents * (a + 1)

a [2] ir ekvivalents * (a + 2)

a [i] ir ekvivalents * (a + i)

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

// Piemērs2.c
# iekļaut
#define 3. rinda
#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));
atgriešanās 0;

2. piemērā.c, atmiņas adrese tiek rādīta heksadecimālā. Atšķirība starp a un + 1 ir 4, kas ir vesela skaitļa lielums baitos.

Tagad apsveriet 2D masīvu:

b ir šāda veida rādītājs: int [] [4] vai int (*) [4]

int [] [4] ir 4 veselu skaitļu rinda. Ja mēs palielinām b par 1, to palielina pēc rindas lieluma.

b ir uzņēmuma adrese 0^th rinda.

b + 1 ir uzņēmuma adrese 1^sv rinda.

b + i ir uzņēmuma adrese i^th rinda.

Rindas lielums ir: (Kolonnas skaits * sizeof (datu tips)) baiti

B skaitļa masīva b [3] [4] rindas lielums ir: 4 * (int) izmērs = 4 * 4 = 16 baiti

2D masīva rindu var uzskatīt par 1D masīvu. b ir uzņēmuma adrese 0^th rinda. Tātad, mēs iegūstam sekojošo

* b + 1 ir uzņēmuma adrese 1^sv elements 0^th
* b + j ir uzņēmuma adrese j^th elements 0^th
* (b + i) ir uzņēmuma adrese 0^th elements i^th
* (b + i) + j ir uzņēmuma adrese j^th elements i^th
b [0] [0] ir līdzvērtīgs ** b
b [0] [1] ir ekvivalents * (* b + 1)
b [1] [0] ir ekvivalents * (* (b + 1))
b [1] [1] ir ekvivalents * (* (b + 1) +1)
b [i] [j] ir ekvivalents * (* (b + i) + j)

B [i] [j] adrese: b + sizeof (datu tips) * (kolonnas skaits * i + j)

Apsveriet 2D masīvu: int b [3] [4]

B [2] [1] adrese ir : b + izmērs (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

// Piemērs3.c
# iekļaut
#define 3. rinda
#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 ("Rindas izmērs:% 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) );
atgriešanās 0;

3. piemērā.c, mēs esam redzējuši, ka rindas lielums decimāldaļās ir 16. Starpība starp b + 1 un b ir 10 heksadecimālā. 10 ar heksadecimālo skaitli ir ekvivalents 16 skaitļiem aiz komata.

Secinājums

Tātad, šajā rakstā mēs esam uzzinājuši par

2D masīva deklarācija
2D masīva inicializēšana
2D masīva atmiņas kartēšana
2D masīva rādītāja aritmētika

Tagad mēs bez šaubām varam izmantot 2D masīvu savā C programmā,

Atsauces

Kredītu par dažām šī darba idejām iedvesmoja kurss “Norādes un 2-D masīvi”, Palaša Dei Datorzinātņu un Engg. Departaments. Indijas Tehnoloģiju institūts Kharagpur