malloc trong C: cấp phát bộ nhớ động, free và sizeof

Mọi mảng bạn viết cho đến giờ đều có kích thước cố định từ lúc biên dịch: int scores[10]; dành sẵn mười ô dù bạn cần ba hay ba trăm. Cách đó ổn cho đến khi kích thước chỉ biết được lúc chương trình chạy, như một tệp có bao nhiêu dòng, người dùng nhập bao nhiêu bản ghi. Bộ nhớ động (dynamic memory) giải quyết điều đó: bạn xin đúng số byte cần, vào lúc cần, và trả lại khi dùng xong.

Các công cụ nằm trong <stdlib.h>:

#include <stdlib.h>

Vì sao có heap

C cho chương trình của bạn hai vùng bộ nhớ chính. Biến cục bộ nằm trong vùng lưu trữ tự động (stack): trình biên dịch quyết định kích thước của chúng, và chúng biến mất ngay khi hàm trả về. Các vùng cấp phát động nằm trong heap: bạn quyết định kích thước lúc chạy, và khối bộ nhớ tồn tại cho đến khi bạn giải phóng nó một cách tường minh.

Tính chất thứ hai đó là lý do thật sự để dùng malloc. Một hàm có thể cấp phát một khối, trả về con trỏ, và bộ nhớ vẫn hợp lệ ở nơi gọi, điều mà một mảng cục bộ không bao giờ làm được. Hai vùng này được so sánh chi tiết trong bài stack và heap.

malloc: xin cấp byte

malloc nhận số byte và trả về một void * trỏ tới chừng đó byte bộ nhớ chưa khởi tạo, hoặc NULL nếu yêu cầu thất bại.

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

int main(void) {
    int n = 5;

    int *scores = malloc(n * sizeof *scores);
    if (scores == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        scores[i] = (i + 1) * 10;
    }

    for (int i = 0; i < n; i++) {
        printf("scores[%d] = %d\n", i, scores[i]);
    }

    free(scores);
    scores = NULL;
    return 0;
}

Bốn điểm trong chương trình ngắn đó là toàn bộ nguyên tắc:

1. Biểu thức kích thước là n * sizeof *scores. Hãy đọc là "n phần tử thuộc kiểu mà scores trỏ tới".
2. Kết quả được kiểm tra với NULL trước mọi lần dùng.
3. Khối bộ nhớ được dùng y như một mảng: scores[i] chạy được vì truy cập chỉ số chính là số học con trỏ.
4. Nó được giải phóng một lần, sau đó con trỏ được gán NULL.

Để ý là không có ép kiểu trên giá trị trả về. Trong C, void * tự động chuyển sang mọi con trỏ đối tượng, và viết (int *)malloc(...) chỉ thêm rối đồng thời che giấu việc thiếu #include <stdlib.h>. (C++ bắt buộc ép kiểu; C thì không.)

Mẫu dùng sizeof

Vì sao dùng sizeof *scores thay vì sizeof(int)? Vì nó không thể bị lỗi thời.

int  *a = malloc(n * sizeof *a);     /* n ints, whatever int is here */
long *b = malloc(n * sizeof *b);     /* same line shape, right size */

/* the fragile form */
long *c = malloc(n * sizeof(int));   /* compiles, allocates too little */

Dòng cuối là một bug thật mà không trình biên dịch nào cảnh báo: c là long *, vùng cấp phát lại tính theo int, và mọi lần ghi vượt quá nửa đầu đều tràn ra ngoài. Với sizeof *c, kích thước tự động theo khai báo.

sizeof *p không giải tham chiếu p: sizeof được tính lúc biên dịch chỉ dựa trên kiểu, nên an toàn ngay cả khi p chưa khởi tạo hoặc là NULL.

Bộ nhớ chưa khởi tạo

malloc không xóa sạch vùng nhớ nó đưa cho bạn. Các byte vẫn chứa bất cứ thứ gì có ở đó từ trước.

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

int main(void) {
    int *p = malloc(4 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    /* reading before writing is undefined behavior - so write first */
    for (int i = 0; i < 4; i++) {
        p[i] = 0;
    }

    printf("%d %d %d %d\n", p[0], p[1], p[2], p[3]);

    free(p);
    return 0;
}

Khi bạn muốn khối bộ nhớ được đặt về 0 sẵn, calloc làm điều đó trong một bước, xem bài calloc và realloc.

free: trả lại bộ nhớ

free(p) trả khối bộ nhớ về cho bộ cấp phát. Ba quy tắc:

• Truyền đúng con trỏ mà malloc trả về, không phải con trỏ đã bị dịch đi. free(p + 1) là undefined behavior.
• Giải phóng mỗi khối đúng một lần. Hai lần là double free, làm hỏng chính sổ sách nội bộ của bộ cấp phát.
• Sau khi giải phóng, con trỏ đã cũ. Dùng nó là use-after-free.

int *p = malloc(sizeof *p);
free(p);
*p = 5;        /* use-after-free - undefined behavior */
free(p);       /* double free - undefined behavior */

Không dòng nào trong đó bắt buộc phải sập ngay, và đó chính là điều khiến chúng nguy hiểm: chương trình có thể chạy vài phút rồi hỏng ở một chỗ chẳng liên quan. Cách phòng vệ rẻ là xóa trắng con trỏ:

free(p);
p = NULL;

free(NULL) được định nghĩa rõ là không làm gì, nên một lần free(p) thứ hai sau đó là vô hại, và *p trở thành một lần sập ngay tại đúng chỗ lỗi thay vì làm hỏng dữ liệu âm thầm.

Một mảng động từ đầu đến cuối

Đây là hình dạng của một lần cấp phát thực tế: đọc số lượng lúc chạy, tính kích thước khối từ đó, dùng nó, giải phóng nó.

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

int main(void) {
    int n = 8;   /* imagine this came from input or a file */

    double *values = malloc((size_t)n * sizeof *values);
    if (values == NULL) {
        fprintf(stderr, "allocation of %d doubles failed\n", n);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        values[i] = 1.0 / (i + 1);
    }

    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += values[i];
    }

    printf("sum of 1/1 .. 1/%d = %f\n", n, sum);
    printf("block holds %zu bytes\n", (size_t)n * sizeof *values);

    free(values);
    values = NULL;
    return 0;
}

Việc ép số lượng sang size_t trở nên quan trọng khi kích thước lớn: n * sizeof *values với n là int thường có thể tràn số trước khi phép nhân kịp tới malloc, tạo ra một khối nhỏ hơn nhiều so với dự định. Nhân trong size_t tránh được điều đó.

Cấp phát bên trong hàm

Quy tắc vòng đời của heap là điều khiến việc này hợp lệ, và cũng là điều khiến việc trả về một mảng cục bộ không hợp lệ:

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

/* caller owns the returned block and must free it */
char *duplicate(const char *text) {
    size_t len = strlen(text);
    char *copy = malloc(len + 1);
    if (copy == NULL) {
        return NULL;
    }
    memcpy(copy, text, len + 1);
    return copy;
}

int main(void) {
    char *greeting = duplicate("hello, heap");
    if (greeting == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    greeting[0] = 'H';
    printf("%s\n", greeting);

    free(greeting);
    return 0;
}

len + 1 chừa chỗ cho ký tự kết thúc null, cùng quy tắc tính kích thước như mọi nơi khác với chuỗi. Và để ý chú thích phía trên hàm: khi một hàm trả về bộ nhớ đã cấp phát, ai giải phóng nó là một phần trong cam kết của hàm. Ghi điều đó ra không phải thủ tục giấy tờ; đó là thứ duy nhất ngăn rò rỉ bộ nhớ.

Struct trên heap

Cùng mẫu đó dùng được cho mọi kiểu:

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

struct Point {
    double x;
    double y;
};

int main(void) {
    struct Point *p = malloc(sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p->x = 3.0;
    p->y = 4.0;
    printf("(%.1f, %.1f)\n", p->x, p->y);

    /* an array of them */
    int n = 3;
    struct Point *path = malloc((size_t)n * sizeof *path);
    if (path == NULL) {
        free(p);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        path[i].x = i;
        path[i].y = i * i;
    }
    printf("last point: (%.1f, %.1f)\n", path[n - 1].x, path[n - 1].y);

    free(path);
    free(p);
    return 0;
}

Để ý nhánh lỗi thứ hai giải phóng p trước khi trả về. Khi một hàm giữ nhiều hơn một vùng cấp phát, mọi đường xử lý lỗi đều phải giải phóng những vùng đã lấy, đây là nguồn phổ biến nhất của các vụ rò rỉ được mô tả trong bài rò rỉ bộ nhớ.

Danh sách kiểm tra

• Luôn kiểm tra malloc với NULL trước lần dùng đầu tiên.
• Tính kích thước bằng n * sizeof *p, nhân trong size_t.
• Không ép kiểu giá trị trả về trong C.
• Bộ nhớ từ malloc chưa được khởi tạo; hãy ghi trước khi đọc.
• Giải phóng đúng một lần, bằng con trỏ gốc, rồi gán nó bằng NULL.
• Mọi đường xử lý lỗi sau một lần cấp phát phải giải phóng những gì đã giữ.