Wskaźnik NULL w C: co oznacza NULL i jak go sprawdzać

Wskaźnik zawsze przechowuje jakąś wartość. Gdy nie ma jeszcze obiektu, na który mógłby wskazywać (przed przypisaniem, po zwolnieniu tego, na co wskazywał, albo gdy funkcja nie ma czego zwrócić), potrzebuje wartości, która jednoznacznie oznacza "tu nic nie ma". Tą wartością jest wskaźnik pusty, a NULL to nazwa, którą piszesz.

Związana z nim dyscyplina jest niewielka i opłaca się bez przerwy: ustawiaj wskaźniki na NULL, gdy nie mają celu, sprawdzaj NULL przed wyłuskaniem i zwracaj NULL, gdy nie masz wyniku.

Czym naprawdę jest NULL

NULL to makro zdefiniowane w <stddef.h> i dołączane też przez <stdio.h>, <stdlib.h>, <string.h> i inne nagłówki. Rozwija się do stałej wskaźnika pustego, zwykle ((void*)0) albo zwykłego 0.

Standard C gwarantuje tę właściwość, która ma znaczenie: wskaźnik pusty jest różny od wskaźnika na jakikolwiek prawdziwy obiekt albo funkcję. Dwa wskaźniki puste tego samego typu są zawsze sobie równe.

#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 ? "tak" : "nie");
    printf("none == NULL? %s\n", none == NULL ? "tak" : "nie");

    return 0;
}

Większość systemów wypisuje dla wskaźnika pustego (nil) albo 0x0, czyli adres zero. To częsta implementacja, a nie reguła; standard nigdy nie obiecuje, że bity są zerami. Obiecuje porównanie, więc pisz p == NULL, a nigdy nic, co zależy od reprezentacji.

Wyłuskanie NULL kończy się awarią

Oto powód istnienia każdego sprawdzenia NULL:

int *p = NULL;
printf("%d\n", *p);   // niezdefiniowane zachowanie: prawie na pewno awaria

Na Windows, macOS i Linuksie pierwsza strona przestrzeni adresowej celowo nie jest zmapowana, więc procesor przechwytuje dostęp, a system operacyjny zabija program. Zobaczysz:

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

Ta natychmiastowa awaria to zaleta. Zamienia błąd logiczny w głośną porażkę dokładnie w linii, która go spowodowała, zamiast cichego uszkodzenia danych, które znajdziesz trzy tygodnie później. Jak czytać taką awarię i znaleźć linię, opisuje strona o błędzie segmentacji.

Dlatego "null pointer" nie jest w C wyjątkiem, który się łapie. Nie ma mechanizmu odzyskiwania; jest tylko sprawdzanie zawczasu.

Sprawdzaj to, co może zawieść

Funkcje, które mogą się nie powieść, sygnalizują to, zwracając NULL. Sprawdzanie nie jest opcjonalną uprzejmością: alternatywą jest awaria.

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

int main(void) {
    // 1. malloc zwraca NULL, gdy przydział się nie powiedzie
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "brak pamieci\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("przydzielono: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. strchr zwraca NULL, gdy znaku nie ma
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("znaleziono 'w' pod indeksem %td\n", found - text);
    }

    const char *missing = strchr(text, 'z');
    printf("znaleziono 'z'? %s\n", missing != NULL ? "tak" : "nie");

    return 0;
}

Biblioteka standardowa jest ich pełna: malloc, calloc, realloc, fopen, strchr, strstr, getenv, bsearch. Każda z nich odpowiada na "brak wyniku" przez NULL. Całą historię przydzielania pamięci opisuje strona o pamięci dynamicznej.

Dwa idiomy sprawdzenia, oba popularne:

if (p == NULL) { /* obsłuż */ }   // jawnie: lepsze dla czytelności
if (!p)        { /* obsłuż */ }   // zwięźle: zakłada, że NULL jest fałszem

Wskaźnik pusty w warunku jest fałszem, a poprawny wskaźnik prawdą, więc oba działają. Forma jawna lepiej się czyta, gdy obca osoba przegląda twój kod w poszukiwaniu błędów.

NULL a 0 a niezainicjalizowany wskaźnik

Trzy różne sytuacje, które początkujący mieszają ze sobą:

int *a = NULL;     "wskazuje na nic": da się sprawdzić, bezpieczny test
int *b;            niezainicjalizowany: zawiera śmieci, NIE da się sprawdzić
int *c = &x;       wskazuje na prawdziwy obiekt

Groźny jest b. Jego bajty to to, co zostało w tym miejscu stosu, a może to być zero (które wygląda dobrze) albo wiarygodnie wyglądający adres z wcześniejszego wywołania. Żadne sprawdzenie nie odróżni go od poprawnego wskaźnika, a zachowanie zmienia się między buildem debug i release.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // na pewno nic

    if (safe == NULL) {
        printf("safe to NULL, mozna to sprawdzic\n");
    }

    // niezainicjalizowanego wskaźnika nie da się sprawdzić; rozwiązanie to go nie mieć
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed zaczyna jako NULL\n");
        fixed = &value;
    }
    printf("fixed wskazuje teraz na %d\n", *fixed);

    return 0;
}

Inicjalizuj każdy wskaźnik. Jeśli nie masz jeszcze adresu, adresem jest NULL. Kompiluj z -Wall -Wextra, a kompilator sam zgłosi wiele użyć niezainicjalizowanych zmiennych.

O 0: w kontekście wskaźnika stała całkowita 0 jest stałą wskaźnika pustego, więc p = 0; to poprawne C. Mimo to wybieraj NULL. Sygnalizuje intencję i ma znaczenie w wywołaniach ze zmienną liczbą argumentów, gdzie kompilator nie może dokonać konwersji za ciebie:

execl("/bin/ls", "ls", 0);       // ryzykowne: może przekazać int tam, gdzie oczekiwany jest wskaźnik
execl("/bin/ls", "ls", (char *)NULL);   // poprawnie

C23 dodaje nullptr, słowo kluczowe z własnym typem, które całkowicie usuwa ten rodzaj niejednoznaczności; NULL pozostaje poprawne i przenośne wszędzie.

Wzorce obronne

Zabezpieczenie na początku funkcji, która przyjmuje wskaźniki.

#include <stdio.h>

// zwraca 0 przy powodzeniu, wartość niezerową przy złych danych
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // odmów zamiast się wysypać
    }
    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("srednia = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("odrzucono tablice NULL zamiast awarii\n");
    }

    return 0;
}

Po zwolnieniu ustaw NULL. free nie zmienia twojego wskaźnika, tylko zwalnia pamięć. Nieaktualny wskaźnik, który zostaje, to wskaźnik wiszący, a jego użycie to niezdefiniowane zachowanie, które często nie kończy się od razu awarią.

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

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

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

    free(p);
    p = NULL;          // teraz pomyłka to głośna awaria, a nie cicha

    if (p == NULL) {
        printf("p to NULL: bezpiecznie sprawdzic, bezpiecznie znow zwolnic\n");
    }

    free(p);           // free(NULL) wprost nic nie robi, zawsze bezpieczne
    return 0;
}

Dwa fakty z tego przykładu warto zapamiętać. free(NULL) z definicji nic nie robi, więc kod sprzątający nigdy nie musi go zabezpieczać. A ustawienie p = NULL po free zamienia użycie po zwolnieniu, które może po cichu uszkodzić dane, w natychmiastową awarię, którą da się zdebugować.

Zwracaj NULL jako "brak wyniku" i mów o tym.

// zwraca wskaźnik na pasujący element albo NULL, jeśli go nie ma
int *find(int *arr, int n, int target);

Udokumentuj to w komentarzu nad funkcją. Wywołujący, który wie, że możliwe jest NULL, napisze sprawdzenie; ten, który nie wie, nie napisze.

Szybka lista kontrolna

• Inicjalizuj każdy wskaźnik prawdziwym adresem albo wartością NULL.
• Sprawdzaj wynik malloc, calloc, realloc i fopen przed użyciem.
• Sprawdzaj parametry wskaźnikowe na początku każdej funkcji, którą można wywołać ze złymi danymi.
• Ustawiaj wskaźniki na NULL od razu po free.
• Pisz NULL, a nie 0, zawsze, gdy chodzi o wskaźnik.
• Buduj z -Wall -Wextra, a gdy możesz, uruchamiaj z sanitizerem: gcc -fsanitize=address,undefined wyłapuje wyłuskania NULL z dokładnym raportem.