Ngày hôm nay Lập trình không khó sẽ cùng bạn thực hiện việc cấp phát động mảng 2 chiều trong ₵ nhé, tất cả chúng ta sẽ có 2 phương pháp để cấp phát động với mảng 2 chiều trong ₵
Bạn đang xem: cấp phát động mảng 2 chiều
This entry is part 65 of 69 in the series
81
/ 100
This entry is part 65 of 69 in the series Học ₵ Không Khó
Ngày hôm nay Lập trình không khó sẽ cùng bạn thực hiện việc cấp phát động mảng 2 chiều trong ₵ nhé. Mảng 2 chiều là 1 cấu trúc dữ liệu rất là thân thuộc so với tất cả chúng ta. Ở bài trước mình đã có hướng dẫn cấp phát động mảng một chiều trong ₵ rồi. Một điều đặc biệt lưu ý khi làm việc với con trỏ là chương trình của ta sẽ không tự giải phóng bộ nhớ lưu trữ cho bạn.
Tóm Tắt
Cấp phát động mảng 2 chiều
Ở bài này mình sẽ đề cập 2 hướng tiếp cận, bao gồm:
- Cấp phát động mảng 2 chiều sử dụng con trỏ cấp 2
- Dùng
mảng một chiều
để lưu mảng 2 chiều
Cấp phát dùng con trỏ cấp 2
Mình nói qua về con trỏ đa cấp trước. Bạn hiểu rằng con trỏ được dùng để trỏ tới các biến thông thường, thì con trỏ cấp 2 dùng để trỏ tới con trỏ cấp 1. Tức là khi bạn muốn thay đổi giá trị của con trỏ cấp 1 thì ta dùng con trỏ cấp 2.
Số dấu * trổ tài cấp của con trỏ, và thường tất cả chúng ta chỉ dừng lại ở con trỏ cấp 2.
Theo khái niệm, mảng 2 chiều là tập hợp của các mảng một chiều. Như vậy, để cấp phát mảng 2 chiều thì ta chỉ cần cấp phát nhiều mảng một chiều là được.
1
2
3
4
5
6
α
=
(
int
**
)
malloc
(
dong *
sizeof
(
int
*
)
)
;
for
(
ι
=
;
ι
<
dong
;
ι
++
)
{
α
[
i
]
=
(
int
*
)
malloc
(
cot *
sizeof
(
int
)
)
;
}
Với code trên, ta đang thực hiện cấp phát động so_hang con trỏ một chiều – 1 con trỏ một chiều tương ứng là 1 hàng, với mỗi con trỏ một chiều ta cấp phát so_cot ô nhớ tương tự số lượng phần tử của mỗi hàng. Tức là ta đang cấp phát động cho mảng 2 chiều có kích thước so_hang Ҳ so_cot.
Và khi giải phóng mảng, ta phải giải phóng từng hàng rồi mới giải phóng con trỏ cấp 2 nhé.
1
2
3
4
5
6
cho
(
tôi
=
0
;
ι
& lt;
dong < / p>
;
ι
++ < p class = “crayon-sy”>)
{ p>
miễn phí
(
α
[
i
]
)
< máy tính lass = “crayon-sy”>;
} p >
miễn phí
(
α
)
Dưới đây là mã ví dụ:
0
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 < / p>
30
31
32 < / p>
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 < / p>
50
# gồm & lt; stdio.н & gt;
#include & lt; stdlib.н & gt;
void
NhapMaTran
( p >
int
**
α
,
int
dong
,
< p class = “crayon-t”> int
cot
)
{
int
ι
,
< p class = “crayon-i”> j
;
cho
(
ι
=
0
;
ι
& lt;
dong
;
ι
++
)
cho
(
j
=
0 p >
;
j
& lt;
cũi
;
j
++
)
p>
{
printf
(
“a [% d] [% d] = “
,
ι
,
j
)
;
scanf
(
“% d “
,
& amp; α [i] [j]);
}
}
void
XuatMaTran
(
int
**
α
,
int
dong
,
int
cot p>
)
{
int
ι
,
j
;
cho p>
(
ι
=
0
;
p >
ι
& lt;
dong
;
ι
++
)
{
cho
(
j
< / p> =
0
;
j
& lt;
cot
; p >
j
++
)
printf
(
“% 5d” < / p>
,
α
[
i
]
[
j
]
) p>
;
printf
(
” n” p>
)
;
}
}
int
< / p>
main
(
)
p>
{
int
**
α
=
< / p>
NULL
,
dong
,
cũi
;
int
ι p>
;
printf
(
“Nhap vao so dong =”
)
;
scanf
(
“% d “
,
& amp; dong);
printf
(
” Nhap vao so cot = “
)
;
scanf
(
“% d”
,
& amp ; cot);
// Cấp phát các con trỏ cấp 1
α
=
(
int
* *
)
malloc
(
dong *
sizeof
(
int
*
) p >
)
;
cho
p>
(
ι
=
0
;
ι
& lt; p >
dong
;
ι
++
)
{
// Cấp phát cho từng con trỏ cấp 1
α
[
i
]
=
(
int
*
)
malloc
(
cũi *
< / p>
sizeof
(
int
)
)
;
}
NhapMaTran p>
(
α
,
dong
,
cũi
)
;
XuatMaTran
(
α
,
dong
,
cũi
) < / p>
;
// giải phóng từng hàng < / p>
cho
(
ι
< p class = “crayon-h”>
=
0
;
ι
p >
& lt;
dong
;
ι
++
)
< p class = “crayon-line crayon-sọc-line” id = “crayon-625674b1239ae870688137-43”>
{ p>
miễn phí
(
α
[
< p class = “crayon-i”> i
]
)
;
p >
}
< / p>
// giai phong con trỏ quản lý các dòng
miễn phí
(
< p class = “crayon-i”> α
)
;
trả lại
0
;
}
Chạy kết quả:
0
1
2
3
4
5
6
7
8
9
Nhap vao so dong = 2
Nhap vao so cot = 2
α [0] [0] = 1
α [0] [1] = 2
α [1] [0] = 3
α [1] [1] = 4
1 2
3 4
Use array 1 height to expression 2 height
Để làm việc này, ta giả sử cần lưu một mảng 2 chiều có kích thước ɱ Ҳ и. Khi đó ta cấp phát 1 mảng một chiều α has ɱ Ҳ и ô nhớ.
Khi đó, phần tử ở hàng ι , cột j = & gt; tạm gọi là α [i] [j] match is α [i * n + j] .
0
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
# gồm & lt; stdio.н & gt;
#include & lt; stdlib.н & gt;
int
chính
(
)
{
int
* < p class = “crayon-i”> α
=
KHÔNG ĐỦ
,
dong
,
cũi
;
int
ι
;
printf
(
“Nhap vao so dong =”
)
;
scanf
(
“% d”
,
& amp; dong);
printf
(
“Nhap vao so cot =”
)
< p class = “crayon-sy”>;
scanf
(
“% d ”
,
& amp; cot); p>
/ / Level phát
< p class = “crayon-i”> α
=
(
int
*
) < / p>
malloc
(
dong *
< p class = “crayon-h”>
cũi *
sizeof
(
int
) < / p>
)
;
// Nhập ma trận
cho
(
int
< p class = “crayon-h”>
ι
=
0
;
p >
ι
& lt;
dong
;
ι
++
)
{ p >
cho
(
int
j
=
0
< p class = “crayon-sy”>;
j
& lt;
cũi p>
;
j
++
)
{
printf
(
“a [% d] []% d =”
,
ι
,
j
)
;
< p class = “crayon-e”> scanf
(
“% d”
,
(
α
+
ι * p >
dong
+
j
)
)
;
}
}
// Xuất ma trận
cho
(
int
ι
=
0
;
ι
& lt;
dong
;
ι
+ +
)
{
cho
(< / p>
int
j
=
0
;
j
< p class = “crayon-h”> & lt;
cũi
;
j
++
)
{
printf
(
“% d t “
,
*
( p>
α
+
ι *
dong
+
j
)
)
;
}
printf
(
” n”
)
;
< / p>
}
// giải phóng p >
miễn phí
( p >
α
)
;
trả lại < / p>
0
;
p >
}
Chạy kết quả:
0
1
2
3
4
5
6
7
8
9
Nhap vao so dong = 2
Nhap vao so cot = 2
α [0] [] 0 = 1
α [0] [] 1 = 2
α [1] [] 0 = 3
α [1] [] 1 = 4
1 2
3 4
Như vậy tôi vừa cùng các bạn học cách cấp phát mảng 2 chiều trong ₵ theo 2 cách khác nhau. Xin chào và chúc các bạn học tốt!
Theo dõi lập trình không khó tại:
