Array 2D

Susunan Dua Dimensi (2D) ialah susunan tatasusunan satu dimensi (1D). Saiz array 1D adalah sama. Susunan 2D juga disebut matriks dengan baris dan lajur.

Mari lihat contoh berikut:

Susunan 3D ini dapat ditunjukkan sebagai tatasusunan 2D seperti berikut:

Mari lihat contoh lain:

Susunan 3D ini tidak dapat ditunjukkan sebagai tatasusunan 2D kerana ukuran susunannya berbeza.

Pengisytiharan larik 2D

jenis data nama susunan[ROW] [COL]

Jenis data adalah jenis data elemen array.
Array-name adalah nama array.
Dua langganan mewakili bilangan baris dan lajur larik. Jumlah elemen array ialah ROW * COL.

int a [2] [3];

Dengan menggunakan kod C di atas, kita dapat menyatakan bilangan bulat susunan, a dari ukuran 2 * 3 (2 Baris dan 3 Tiang).

char b [3] [2];

Dengan menggunakan kod C di atas, kita dapat menyatakan a watak susunan, b dari ukuran 2 * 3 (3 Baris dan 2 Lajur).

Permulaan array 2D

Kita boleh memulakan semasa pengisytiharan dengan cara berikut:

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;

Perhatikan bahawa dalam 2 dan 4 kita belum menyebutkan 1^st langganan. Penyusun C secara automatik mengira bilangan baris dari bilangan elemen. Tetapi 2^nd langganan mesti dinyatakan. Permulaan berikut tidak sah:

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

// Contoh1.c
#sertakan
#tentukan ROW 3
#tentukan COL 2
int utama ()

int i, j;
int a [ROW] [COL] =
1,2,
3,4,
5,6
;
printf ("Elemen bijak baris dari array a adalah: \ n");
untuk (i = 0; i
printf ("Baris% d:", i);
untuk (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nElemen kolum bijak dari array a adalah: \ n");
untuk (i = 0; i
printf ("Lajur% d:", i);
untuk (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

pulangan 0;

Dalam Contoh1.c, kami telah menyatakan susunan bilangan bulat ukuran 3 * 2 dan diinisialisasi. Untuk mengakses elemen array, kami menggunakan dua untuk gelung.

Untuk mengakses baris, gelung luar adalah untuk baris, dan gelung dalaman adalah untuk lajur.

Untuk mengakses mengikut lajur, gelung luar adalah untuk lajur, dan gelung dalaman adalah untuk baris.

Perhatikan bahawa ketika kita menyatakan array 2D, kita menggunakan [2] [3], yang bermaksud 2 baris dan 3 lajur. Pengindeksan array bermula dari 0. Untuk mengakses 2^nd baris dan 3^rd lajur, kita mesti menggunakan notasi a [1] [2].

Pemetaan memori bagi array 2D

Pandangan logik bagi tatasusunan a [3] [2] mungkin seperti berikut:

Memori komputer adalah urutan bait 1D. Dalam bahasa C, penyimpanan array 2D dalam memori di pesanan baris-utama. Beberapa bahasa pengaturcaraan lain (e.g., FORTRAN), ia menyimpan di susunan lajur-utama dalam ingatan.

Pointer Arithmetik bagi array 2D

Untuk memahami aritmetik penunjuk bagi array 2D, pertama-tama, lihat pada array 1D.

Pertimbangkan array 1D:

Dalam susunan 1D, a adalah pemalar, dan nilainya adalah alamat 0^ika lokasi tatasusunan a [5]. Nilai a + 1 adalah alamat 1^st lokasi tatasusunan a [5]. a + i adalah alamat i^ika lokasi tatasusunan.

Sekiranya kita bertambah a oleh 1, ia bertambah dengan ukuran jenis data.

a [1] adalah bersamaan dengan * (a + 1)

a [2] adalah bersamaan dengan * (a + 2)

a [i] adalah bersamaan dengan * (a + i)

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

// Contoh2.c
#sertakan
#tentukan ROW 3
#tentukan COL 2
int utama ()

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));
pulangan 0;

Dalam Contoh2.c, alamat memori ditunjukkan dalam heksadesimal. Perbezaan antara a dan a + 1 adalah 4, yang merupakan ukuran bilangan bulat dalam bait.

Sekarang, pertimbangkan array 2D:

b adalah penunjuk jenis: int [] [4] atau int (*) [4]

int [] [4] ialah baris 4 integer. Jika kita menambah b dengan 1, itu akan bertambah dengan ukuran baris.

b adalah alamat 0^ika barisan.

b + 1 adalah alamat 1^st barisan.

b + i adalah alamat i^ika barisan.

Saiz baris adalah: (Bilangan lajur * sizeof (jenis data)) bait

Ukuran baris bagi bilangan bulat bilangan bulat b [3] [4] ialah: 4 * sizeof (int) = 4 * 4 = 16 bait

Baris array 2D boleh dilihat sebagai tatasusunan 1D. b adalah alamat 0^ika barisan. Jadi, kami mendapat perkara berikut

* b + 1 adalah alamat 1^st unsur 0^ika
* b + j adalah alamat j^ika unsur 0^ika
* (b + i) adalah alamat 0^ika unsur i^ika
* (b + i) + j adalah alamat j^ika unsur i^ika
b [0] [0] bersamaan dengan ** b
b [0] [1] bersamaan dengan * (* b + 1)
b [1] [0] bersamaan dengan * (* (b + 1))
b [1] [1] bersamaan dengan * (* (b + 1) +1)
b [i] [j] bersamaan dengan * (* (b + i) + j)

Alamat b [i] [j]: b + sizeof (jenis data) * (Jumlah lajur * i + j)

Pertimbangkan array 2D: int b [3] [4]

Alamat b [2] [1] ialah : 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

// Contoh3.c
#sertakan
#tentukan ROW 3
#tentukan COL 4
int utama ()

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 ("Saiz baris:% 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) );
pulangan 0;

Dalam Contoh3.c, kita telah melihat bahawa ukuran baris adalah 16 dalam notasi perpuluhan. Perbezaan antara b + 1 dan b adalah 10 dalam heksadesimal. 10 dalam heksadesimal bersamaan dengan 16 dalam perpuluhan.

Kesimpulannya

Oleh itu, dalam artikel ini, kita telah mengetahui tentang

Pengisytiharan larik 2D
Permulaan array 2D
Pemetaan memori bagi array 2D
Pointer Arithmetic dari array 2D

Sekarang kita dapat menggunakan array 2D dalam program C kita tanpa keraguan,

Rujukan

Kredit untuk beberapa idea dalam karya ini diilhamkan oleh kursus, Pointers and 2-D Arrays, oleh Palash Dey Department of Computer Science & Engg. Institut Teknologi India Kharagpur