2D tömb

A kétdimenziós (2D) tömb egydimenziós (1D) tömbök tömbje. Az 1D tömb méretei megegyeznek. A 2D tömböt mátrixnak is nevezzük sorokkal és oszlopokkal.

Lássuk a következő példát:

Ez a 3 1D tömb 2D tömbként ábrázolható az alábbiak szerint:

Lássunk egy másik példát:

Ez a 3 1D tömb nem képviselhet 2D tömbként, mert a tömbök méretei különbözőek.

A 2D tömb deklarációja

adattípus tömb-név[SOR] [COL]

Adattípus a tömb elemek adattípusa.
A tömb neve a tömb neve.
Két előfizetés jelzi a tömb sorainak és oszlopainak számát. A tömb elemeinek teljes száma ROW * COL lesz.

int a [2] [3];

A fenti C kód használatával deklarálhatunk egy egész szám sor, a nagyságú 2 * 3 (2 sor és 3 oszlop).

char b [3] [2];

A fenti C kód használatával kijelenthetjük a karakter sor, b nagyságú 2 * 3 (3 sor és 2 oszlop).

2D tömb inicializálása

A nyilatkozat során a következő módszerekkel inicializálhatjuk:

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;

Vegye figyelembe, hogy a 2. és a 4. részben nem említettük az 1-et^utca alindex. A C fordító automatikusan kiszámítja a sorok számát az elemek számából. De a 2^nd alindexet meg kell adni. A következő inicializálások érvénytelenek:

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élda1.c
#include
#define 3. sor
#define COL 2
int main ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Az a tömb soros elemei: \ n");
mert (i = 0; i
printf ("% d sor:", i);
mert (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nAz oszlop bölcs elemei: \ n");
mert (i = 0; i
printf ("% d oszlop:", i);
mert (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

visszatér 0;

Az 1. példában.c, deklaráltunk egy 3 * 2 méretű egész tömböt és inicializáltuk. A tömb elemek eléréséhez kettőt használunk a hurokhoz.

A sorok szerinti eléréshez a külső hurok a soroké, a belső hurok pedig az oszlopoké.

Oszloponként történő eléréshez a külső hurok az oszlopoké, a belső hurok pedig a soroké.

Ne feledje, hogy amikor 2D tömböt deklarálunk, akkor egy [2] [3] szót használunk, ami 2 sort és 3 oszlopot jelent. A tömbindexelés 0-tól kezdődik. A 2 eléréséhez^nd sor és 3^rd oszlopban az a [1] [2] jelölést kell használnunk.

2D tömb memória leképezése

Egy tömb logikai nézete a [3] [2] lehet a következő:

A számítógépes memória egy bájtos 1D-sorrend. C nyelven 2D tömb tár a memóriában sor-fő rend. Néhány más programozási nyelv (pl.g., FORTRAN), itt tárolja oszlop-fő rend a memóriában.

2D tömb mutatószámtana

A 2D tömb mutató-aritmetikájának megértéséhez először nézze meg az 1D tömböt.

Vegyünk egy 1D tömböt:

1D tömbben, a konstans, értéke pedig a 0 címe^th a tömb helye a [5]. Értéke a + 1 az 1 címe^utca a tömb helye a [5]. a + i a. címe én^th a tömb helye.

Ha növekszünk a 1-gyel növekszik az adattípus méretével.

a [1] egyenértékű * (a + 1)

a [2] egyenértékű * (a + 2)

a [i] egyenértékű * (a + i)

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

// 2. példa.c
#include
#define 3. sor
#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));
visszatér 0;

A 2. példában.c, a memória címe hexadecimálisan jelenik meg. Az a és a + 1 közötti különbség 4, amely egy bájtban lévő egész méret.

Vegyünk egy 2D tömböt:

b típusú mutató: int [] [4] vagy int (*) [4]

int [] [4] egy 4 egész sor. Ha b-vel növekszünk 1-gyel, akkor azt a sor mérete növeli.

b a. címe 0^th sor.

b + 1 a. címe 1^utca sor.

b + i a címe én^th sor.

A sor mérete: (Oszlop száma * sizeof (adattípus)) bájt

A b [3] [4] egész tömb sorának mérete: 4 * (int) mérete = 4 * 4 = 16 bájt

A 2D tömb sora 1D tömbnek tekinthető. b a. címe 0^th sor. Tehát a következőket kapjuk

* b + 1 a. címe 1^utca eleme a 0^th
* b + j a. címe j^th eleme a 0^th
* (b + i) a. címe 0^th eleme a én^th
* (b + i) + j a. címe j^th eleme a én^th
b [0] [0] egyenértékű ** b-vel
b [0] [1] egyenértékű * (* b + 1)
b [1] [0] egyenértékű * (* (b + 1))
b [1] [1] egyenértékű * (* (b + 1) +1)
b [i] [j] egyenértékű * (* (b + i) + j)

B [i] [j] címe: b + sizeof (adattípus) * (oszlop száma * i + j)

Vegyünk egy 2D tömböt: int b [3] [4]

B [2] [1] címe: : b + méret (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. példa.c
#include
#define 3. sor
#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 ("Egy sor mérete:% 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) );
visszatér 0;

A 3. példában.c, azt láttuk, hogy egy sor mérete decimális jelöléssel 16. A b + 1 és b közötti különbség 10 hexadecimális értékben. A hexadecimális 10 egyenértékű a decimális 16-val.

Következtetés

Tehát ebben a cikkben megtudtuk

A 2D tömb deklarációja
2D tömb inicializálása
2D tömb memória leképezése
A 2D tömb mutatószámtana

Most minden kétség nélkül használhatjuk a 2D tömböt a C programunkban,

Hivatkozások

A munka néhány ötletének elismerését a „Pointers and 2-D Arrays” tanfolyam inspirálta, Palash Dey Számítástudományi és Engg Tanszék. Indiai Műszaki Intézet Kharagpur