Cấp phát động (malloc/free)

Biến cục bộ trên stack có hai giới hạn: biến mất khi hàm trả về, và phải biết kích thước lúc biên dịch. Khi cần bộ nhớ có kích thước quyết định lúc chạy hoặc sống lâu hơn một hàm, ta xin trên heap bằng malloc:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 3;
    int *arr = malloc(n * sizeof(int));  // mang n phan tu luc chay
    arr[0] = 10; arr[1] = 20; arr[2] = 30;
    printf("%d\n", arr[1]);   // 20
    free(arr);                 // tra lai khi xong
    return 0;
}

20

• ▸malloc(số_byte) → con trỏ tới khối trên heap (hoặc NULL nếu hết bộ nhớ).
• ▸Tính kích thước bằng sizeof: n * sizeof(int), không hardcode số byte.
• ▸Khối heap sống tới khi free - không tự biến mất khi hàm trả về.

Chu trình chuẩn: xin → kiểm tra NULL → dùng → free → đặt NULL. Chọn các ví dụ bên dưới (đúng cách, rồi ba lỗi kinh điển) và bấm Bước tiếp để xem heap thay đổi - ô đỏ báo bước có lỗi:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *p = malloc(sizeof(int));
    if (p == NULL) return 1;   // luon kiem tra
    *p = 42;
    printf("%d\n", *p);        // 42
    free(p);                   // tra lai
    p = NULL;                  // tranh con tro treo
    return 0;
}

42

Hai họ hàng của malloc. calloc cấp phát VÀ xoá trắng về 0; realloc đổi kích thước một khối đã cấp (giữ dữ liệu cũ):

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *a = calloc(2, sizeof(int)); // 2 phan tu, TAT CA = 0
    printf("%d\n", a[0]);            // 0  (calloc xoa trang)

    int *tmp = realloc(a, 4 * sizeof(int)); // mo rong len 4 phan tu
    if (tmp == NULL) { free(a); return 1; }    // that bai: khoi cu VAN con
    a = tmp;
    a[2] = 30;                       // giu a[0], a[1] cu; them cho moi
    printf("%d %d\n", a[0], a[2]);   // 0 30
    free(a);
    return 0;
}

0
0 30

• ▸calloc(n, size): cấp n×size byte và đặt tất cả về 0.
• ▸realloc(p, size_mới): đổi kích thước, GIỮ dữ liệu cũ; có thể dời khối.
• ▸Nhận kết quả realloc vào con trỏ TẠM (tmp) rồi mới gán - tránh mất khối cũ khi realloc trả NULL.

Phần lớn lỗi nghiêm trọng trong C đến từ heap. Vừa đọc vừa mở lại các ví dụ ở Bước 2 để đối chiếu:

• ▸Rò rỉ (leak): malloc nhưng quên free (hoặc mất con trỏ) → khối kẹt mãi, ngốn RAM.
• ▸Dùng sau free (use-after-free): truy cập qua con trỏ đã free → hành vi không xác định.
• ▸Free hai lần (double free): free cùng một khối hai lần → hỏng cấu trúc quản lý heap.

Vài quy tắc đơn giản loại bỏ phần lớn lỗi heap:

• ▸Mỗi malloc/calloc ↔ đúng MỘT free. Nghĩ ngay tới free khi viết malloc.
• ▸Luôn kiểm tra kết quả malloc khác NULL trước khi dùng.
• ▸Sau free(p), đặt p = NULL (free(NULL) vô hại; tránh dùng lại con trỏ treo).
• ▸Mỗi khối có MỘT “chủ sở hữu” rõ ràng chịu trách nhiệm free.
• ▸realloc: luôn gán lại con trỏ bằng giá trị trả về.