Con trỏ NULL trong C: NULL là gì và cách kiểm tra

Con trỏ (pointer) luôn giữ một giá trị nào đó. Khi nó chưa có đối tượng nào để trỏ tới, như trước khi được gán, sau khi thứ nó trỏ tới đã bị giải phóng, hoặc khi một hàm không có gì để trả về, nó cần một giá trị mang nghĩa rõ ràng là "không có gì ở đây". Giá trị đó là con trỏ null, và NULL là cái tên bạn viết ra.

Kỷ luật xoay quanh nó rất gọn mà lại luôn đáng công: gán con trỏ bằng NULL khi nó chưa có đích, kiểm tra NULL trước khi dereference, và trả về NULL khi không có kết quả.

NULL thực chất là gì

NULL là một macro, được định nghĩa trong <stddef.h> và cũng được kéo vào qua <stdio.h>, <stdlib.h>, <string.h> cùng nhiều header khác. Nó được mở rộng thành một hằng con trỏ null, thường là ((void*)0) hoặc đơn giản là 0.

Chuẩn C đảm bảo tính chất quan trọng nhất: một con trỏ null luôn so sánh khác với con trỏ tới bất kỳ đối tượng hay hàm có thật nào. Hai con trỏ null cùng kiểu thì luôn bằng nhau.

#include <stdio.h>

int main(void) {
    int value = 42;
    int *good = &value;
    int *none = NULL;

    printf("good = %p\n", (void *)good);
    printf("none = %p\n", (void *)none);

    printf("\ngood == NULL? %s\n", good == NULL ? "yes" : "no");
    printf("none == NULL? %s\n", none == NULL ? "yes" : "no");

    return 0;
}

Phần lớn hệ thống in con trỏ null ra là (nil) hoặc 0x0, tức địa chỉ 0. Đó là cách cài đặt phổ biến chứ không phải quy tắc; chuẩn C không hề hứa các bit đều bằng 0. Điều nó hứa là phép so sánh, nên hãy viết p == NULL, đừng viết bất cứ thứ gì phụ thuộc vào cách biểu diễn.

Dereference NULL gây crash

Đây là lý do của mọi phép kiểm tra null từng được viết ra:

int *p = NULL;
printf("%d\n", *p);   // undefined behavior - almost certainly a crash

Trên Windows, macOS và Linux, trang đầu tiên của không gian địa chỉ được cố tình để trống, nên CPU chặn lần truy cập đó và hệ điều hành dừng chương trình. Bạn sẽ thấy:

Segmentation fault (core dumped)          # Linux
zsh: segmentation fault  ./program        # macOS

Cú crash tức thì đó là một tính năng. Nó biến một lỗi logic thành một thất bại ồn ào ngay tại dòng gây ra lỗi, thay vì một lần hỏng dữ liệu âm thầm mà ba tuần sau bạn mới phát hiện. Xem bài segmentation fault để biết cách đọc thông báo crash và tìm ra dòng lỗi.

Vì thế trong C, "null pointer" không phải là ngoại lệ mà bạn có thể bắt. Không có cơ chế nào để phục hồi; chỉ có cách kiểm tra trước.

Kiểm tra những gì có thể thất bại

Các hàm có thể thất bại sẽ báo hiệu bằng cách trả về NULL. Kiểm tra không phải là phép lịch sự tùy chọn: không kiểm tra thì sẽ crash.

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

int main(void) {
    // 1. malloc returns NULL when allocation fails
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("allocated ok: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. strchr returns NULL when the character is not found
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("found 'w' at index %td\n", found - text);
    }

    const char *missing = strchr(text, 'z');
    printf("'z' found? %s\n", missing != NULL ? "yes" : "no");

    return 0;
}

Thư viện chuẩn có đầy những hàm như vậy: malloc, calloc, realloc, fopen, strchr, strstr, getenv, bsearch. Tất cả đều trả lời "không có kết quả" bằng NULL. Xem bài cấp phát bộ nhớ động để hiểu đầy đủ về việc cấp phát.

Có hai cách viết phép kiểm tra, cả hai đều phổ biến:

if (p == NULL) { /* handle */ }   // explicit - preferred for clarity
if (!p)        { /* handle */ }   // terse - relies on NULL being falsy

Trong một điều kiện, con trỏ null được coi là sai còn con trỏ hợp lệ được coi là đúng, nên cả hai cách đều chạy. Cách viết tường minh dễ đọc hơn khi người lạ lướt qua code của bạn để tìm bug.

NULL, 0 và con trỏ chưa khởi tạo

Ba tình huống khác nhau mà người mới hay nhầm lẫn:

int *a = NULL;     "points at nothing" - testable, safe to check
int *b;            uninitialized - holds garbage, NOT testable
int *c = &x;       points at a real object

Nguy hiểm nhất là b. Các byte của nó là bất cứ thứ gì còn sót lại trong ô nhớ stack đó, có thể bằng 0 (và trông như ổn), cũng có thể là một địa chỉ trông rất hợp lý từ một lời gọi hàm trước đó. Không phép kiểm tra nào phân biệt được nó với một con trỏ hợp lệ, và hành vi còn thay đổi giữa bản build debug và bản build release.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // definitely nothing

    if (safe == NULL) {
        printf("safe is null - we can test for this\n");
    }

    // an uninitialized pointer cannot be tested; the fix is not to have one
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed starts null\n");
        fixed = &value;
    }
    printf("fixed now points at %d\n", *fixed);

    return 0;
}

Khởi tạo mọi con trỏ. Nếu chưa có địa chỉ nào, thì NULL chính là địa chỉ. Biên dịch với -Wall -Wextra và trình biên dịch sẽ cảnh báo giúp bạn nhiều chỗ dùng biến chưa khởi tạo.

Về 0: trong ngữ cảnh con trỏ, hằng số nguyên 0 chính là hằng con trỏ null, nên p = 0; là C hợp lệ. Dù vậy vẫn nên dùng NULL. Nó thể hiện rõ ý định, và nó quan trọng trong các lời gọi variadic, nơi trình biên dịch không thể tự chuyển kiểu giúp bạn:

execl("/bin/ls", "ls", 0);       // risky - may pass an int where a pointer is expected
execl("/bin/ls", "ls", (char *)NULL);   // correct

C23 bổ sung nullptr, một từ khóa có kiểu riêng, loại bỏ hoàn toàn kiểu mơ hồ này; NULL vẫn đúng và chạy được ở mọi nơi.

Các cách viết phòng thủ

Kiểm tra ngay đầu hàm nhận con trỏ.

#include <stdio.h>

// returns 0 on success, nonzero on bad input
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // refuse rather than crash
    }
    long total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    *out = (double)total / n;
    return 0;
}

int main(void) {
    int data[4] = {10, 20, 30, 41};
    double result;

    if (average(data, 4, &result) == 0) {
        printf("average = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("rejected a NULL array instead of crashing\n");
    }

    return 0;
}

Gán NULL sau khi giải phóng. free không thay đổi con trỏ của bạn, nó chỉ trả lại vùng nhớ. Con trỏ cũ còn sót lại là một con trỏ treo (dangling pointer), và dùng nó là undefined behavior, thường không crash ngay.

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

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

    *p = 99;
    printf("value = %d\n", *p);

    free(p);
    p = NULL;          // now the mistake is a loud crash, not a quiet one

    if (p == NULL) {
        printf("p is null - safe to test, safe to free again\n");
    }

    free(p);           // free(NULL) is explicitly a no-op, always safe
    return 0;
}

Có hai điều trong ví dụ trên đáng ghi nhớ. free(NULL) được định nghĩa là không làm gì cả, nên code dọn dẹp không bao giờ cần kiểm tra trước. Và gán p = NULL sau free biến một lỗi use-after-free, vốn có thể âm thầm làm hỏng dữ liệu, thành một cú crash tức thì và dễ gỡ lỗi.

Trả về NULL để báo "không có kết quả", và ghi rõ điều đó.

// returns a pointer to the matching element, or NULL if there is none
int *find(int *arr, int n, int target);

Ghi lại điều đó trong chú thích phía trên hàm. Người gọi biết có thể nhận NULL sẽ viết phép kiểm tra; người không biết thì sẽ không viết.

Danh sách kiểm tra nhanh

• Khởi tạo mọi con trỏ, bằng một địa chỉ thật hoặc bằng NULL.
• Kiểm tra giá trị trả về của malloc, calloc, realloc và fopen trước khi dùng.
• Kiểm tra tham số con trỏ ở đầu mọi hàm có thể bị gọi với đầu vào sai.
• Gán con trỏ bằng NULL ngay sau free.
• Viết NULL chứ không phải 0 mỗi khi muốn nói tới con trỏ.
• Build với -Wall -Wextra và, khi có thể, chạy với sanitizer: gcc -fsanitize=address,undefined bắt được lỗi dereference null kèm báo cáo chính xác.