2D pole

Dvourozměrné (2D) pole je pole jednorozměrných (1D) polí. Velikosti 1D pole jsou stejné. 2D pole se také nazývá matice s řádky a sloupci.

Podívejme se na následující příklad:

Tyto 3 1D pole lze reprezentovat jako 2D pole následujícím způsobem:

Podívejme se na další příklad:

Tyto 3 1D pole nelze představovat jako 2D pole, protože velikosti polí se liší.

Deklarace 2D pole

datový typ název pole[ŘÁDEK] [COL]

Datový typ je datový typ prvků pole.
Array-name je název pole.
Dva dolní indexy představují počet řádků a sloupců pole. Celkový počet prvků pole bude ROW * COL.

int [2] [3];

Pomocí výše uvedeného C kódu můžeme deklarovat celé číslo pole, A velikosti 2 * 3 (2 řádky a 3 sloupce).

char b [3] [2];

Pomocí výše uvedeného C kódu můžeme deklarovat a charakter pole, b velikosti 2 * 3 (3 řádky a 2 sloupce).

Inicializace 2D pole

Během deklarace můžeme inicializovat následujícími způsoby:

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;

Všimněte si, že v 2 a 4 jsme nezmínili 1^Svatý dolní index. Kompilátor C automaticky vypočítá počet řádků z počtu prvků. Ale 2^nd musí být uveden dolní index. Následující inicializace jsou neplatné:

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

// Příklad 1.C
#zahrnout
#define 3. ŘADA
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Řádky Prvky pole a jsou: \ n");
pro (i = 0; i
printf ("Řádek% d:", i);
pro (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nSloupec Prvky pole a jsou: \ n");
pro (i = 0; i
printf ("Sloupec% d:", i);
pro (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

návrat 0;

V příkladu 1.c, deklarovali jsme celé číslo o velikosti 3 * 2 a inicializovali jsme. Pro přístup k prvkům pole používáme dva pro smyčku.

Pro přístup po řádcích je vnější smyčka pro řádky a vnitřní smyčka pro sloupce.

Pro přístup po sloupcích je vnější smyčka pro sloupce a vnitřní smyčka pro řádky.

Všimněte si, že když deklarujeme 2D pole, použijeme [2] [3], což znamená 2 řádky a 3 sloupce. Indexování polí začíná od 0. Pro přístup k 2^nd řádek a 3^rd sloupec, musíme použít notaci a [1] [2].

Mapování paměti 2D pole

Logický pohled na pole a [3] [2] může být následující:

Paměť počítače je 1D sekvence bajtů. V jazyce C ukládá 2D pole do paměti v řádková hlavní objednávka. Některé další programovací jazyky (např.G., FORTRAN), ukládá se do sloupová hlavní objednávka v paměti.

Aritmetika ukazatele 2D pole

Abyste pochopili aritmetiku ukazatele 2D pole, nejprve se podívejte na 1D pole.

Zvažte 1D pole:

V 1D poli, A je konstanta a její hodnota je adresa 0^th umístění pole a [5]. Hodnota a + 1 je adresa 1^Svatý umístění pole a [5]. a + i je adresa i^th umístění pole.

Pokud zvýšíme A o 1 se zvýší o velikost datového typu.

a [1] je ekvivalentní k * (a + 1)

a [2] je ekvivalentní k * (a + 2)

a [i] je ekvivalentní k * (a + i)

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

// Příklad 2.C
#zahrnout
#define 3. ŘADA
#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));
návrat 0;

V příkladu 2.c, adresa paměti se zobrazuje v šestnáctkové soustavě. Rozdíl mezi a a + 1 je 4, což je velikost celého čísla v bajtech.

Nyní zvažte 2D pole:

b je ukazatel typu: int [] [4] nebo int (*) [4]

int [] [4] je řada 4 celých čísel. Pokud zvýšíme b o 1, zvýší se to o velikost řádku.

b je adresa 0^th řádek.

b + 1 je adresa 1^Svatý řádek.

b + i je adresa i^th řádek.

Velikost řádku je: (Počet sloupců * sizeof (datový typ)) bajtů

Velikost řádku celočíselného pole b [3] [4] je: 4 * sizeof (int) = 4 * 4 = 16 bajtů

Řadu 2D pole lze považovat za 1D pole. b je adresa 0^th řádek. Takže máme následující

* b + 1 je adresa 1^Svatý prvek 0^th
* b + j je adresa j^th prvek 0^th
* (b + i) je adresa 0^th prvek i^th
* (b + i) + j je adresa j^th prvek i^th
b [0] [0] odpovídá ** b
b [0] [1] odpovídá * (* b + 1)
b [1] [0] odpovídá * (* (b + 1))
b [1] [1] odpovídá * (* (b + 1) +1)
b [i] [j] odpovídá * (* (b + i) + j)

Adresa b [i] [j]: b + sizeof (datový typ) * (počet sloupců * i + j)

Zvažte 2D pole: int b [3] [4]

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

// Příklad 3.C
#zahrnout
#define 3. ŘADA
#define COL 4
int main ()

int i, j;
int b [ROW] [COL] =
10,20,30,40,
50,60,70,80,
90 100 110 110 120
;
printf ("sizeof (int):% ld \ n", sizeof (int));
printf ("Velikost řádku:% 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) );
návrat 0;

V příkladu 3.c, viděli jsme, že velikost řádku je 16 v desítkové soustavě. Rozdíl mezi b + 1 a b je 10 v šestnáctkové soustavě. 10 v šestnáctkové soustavě odpovídá 16 v desítkové soustavě.

Závěr

V tomto článku jsme se tedy dozvěděli o

Deklarace 2D pole
Inicializace 2D pole
Mapování paměti 2D pole
Aritmetika ukazatele 2D pole

Nyní můžeme v našem programu C bez jakýchkoli pochyb použít 2D pole,

Reference

Zásluhu na některých nápadech v této práci inspiroval kurz Pointers and 2-D Arrays od Palash Dey Department of Computer Science & Engg. Indický technologický institut Kharagpur