NULL-указатели в C: что такое NULL и как его проверять

Указатель всегда хранит какое-то значение. Когда объекта для указания ещё нет — до присваивания, после освобождения того, на что он указывал, или когда функции нечего вернуть — нужно значение, которое недвусмысленно означает «здесь ничего». Это значение — нулевой указатель, и пишется оно как NULL.

Дисциплина вокруг него несложная и постоянно окупается: присваивайте указателям NULL, когда у них нет цели, проверяйте на NULL перед разыменованием и возвращайте NULL, когда результата нет.

Что такое NULL на самом деле

NULL — это макрос, определённый в <stddef.h> и подтягиваемый заодно из <stdio.h>, <stdlib.h>, <string.h> и других. Он раскрывается в нулевую указательную константу — обычно ((void*)0) или просто 0.

Стандарт C гарантирует главное свойство: нулевой указатель не равен указателю ни на один реальный объект или функцию. Два нулевых указателя одного типа всегда равны друг другу.

#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 ? "да" : "нет");
    printf("none == NULL? %s\n", none == NULL ? "да" : "нет");

    return 0;
}

Большинство систем выводит для нулевого указателя (nil) или 0x0 — нулевой адрес. Это распространённая реализация, а не правило; стандарт нигде не обещает, что биты нулевые. Он обещает результат сравнения, поэтому пишите p == NULL и никогда не полагайтесь на представление.

Разыменование NULL роняет программу

Причина существования всех проверок на null:

int *p = NULL;
printf("%d\n", *p);   // неопределённое поведение - почти наверняка падение

В Windows, macOS и Linux первая страница адресного пространства намеренно оставлена неотображённой, поэтому процессор перехватывает обращение, а операционная система убивает программу. Вы увидите:

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

Это немедленное падение — достоинство. Оно превращает логическую ошибку в громкий сбой ровно на той строке, которая его вызвала, вместо тихой порчи данных, которую вы обнаружите через три недели. О том, как прочитать такое падение и найти строку, — в статье ошибка сегментации.

Именно поэтому «null pointer» в C — не исключение, которое можно перехватить. Механизма восстановления нет; есть только проверка заранее.

Проверяйте то, что может не получиться

Функции, которые могут завершиться неудачей, сигнализируют об этом, возвращая NULL. Проверка — не факультативная вежливость: альтернатива ей — падение.

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

int main(void) {
    // 1. malloc возвращает NULL, когда выделить память не удалось
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "не хватает памяти\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("память выделена: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. strchr возвращает NULL, когда символ не найден
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("'w' найден по индексу %td\n", found - text);
    }

    const char *missing = strchr(text, 'z');
    printf("'z' найден? %s\n", missing != NULL ? "да" : "нет");

    return 0;
}

Стандартная библиотека полна таких функций: malloc, calloc, realloc, fopen, strchr, strstr, getenv, bsearch. Каждая из них отвечает «результата нет» значением NULL. Полная история про выделение памяти — в статье динамическая память.

Две одинаково распространённые формы проверки:

if (p == NULL) { /* обработка */ }   // явная - предпочтительна для ясности
if (!p)        { /* обработка */ }   // краткая - опирается на ложность NULL

Нулевой указатель в условии считается ложным, а корректный — истинным, поэтому работают обе. Явная форма читается лучше, когда посторонний человек просматривает ваш код в поисках багов.

NULL против 0 и против неинициализированного

Три разные ситуации, которые новички смешивают в одну:

int *a = NULL;     "не указывает ни на что" - проверяемо и безопасно
int *b;            неинициализирован - хранит мусор, НЕ проверяем
int *c = &x;       указывает на реальный объект

Опасен здесь b. Его байты — это то, что осталось в этой ячейке стека: может быть, ноль (и тогда всё выглядит нормально), а может быть, правдоподобный адрес от более раннего вызова. Никакая проверка не отличит его от корректного указателя, а поведение меняется между отладочной и релизной сборками.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // точно ничего

    if (safe == NULL) {
        printf("safe равен null - это мы можем проверить\n");
    }

    // неинициализированный указатель проверить нельзя; решение - не заводить его
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed начинает с null\n");
        fixed = &value;
    }
    printf("теперь fixed указывает на %d\n", *fixed);

    return 0;
}

Инициализируйте каждый указатель. Если адреса ещё нет, то адрес — это NULL. Собирайте с -Wall -Wextra, и компилятор сам укажет вам на многие случаи использования неинициализированных значений.

Про 0: в указательном контексте целочисленная константа 0 и есть нулевая указательная константа, поэтому p = 0; — корректный C. И всё же предпочитайте NULL. Он выражает намерение, и это важно в вызовах с переменным числом аргументов, где компилятор не может выполнить преобразование за вас:

execl("/bin/ls", "ls", 0);       // рискованно - вместо указателя может уйти int
execl("/bin/ls", "ls", (char *)NULL);   // правильно

В C23 появился nullptr — ключевое слово с собственным типом, полностью снимающее эту неоднозначность; NULL при этом остаётся корректным и переносимым везде.

Защитные приёмы

Проверяйте в начале функции, принимающей указатели.

#include <stdio.h>

// возвращает 0 при успехе и ненулевое значение при некорректном вводе
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // отказаться, а не упасть
    }
    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("среднее = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("массив NULL отвергнут вместо падения\n");
    }

    return 0;
}

Присваивайте NULL после освобождения. free не меняет ваш указатель — он только отдаёт память. Оставшийся устаревший указатель называется висячим, и его использование — неопределённое поведение, которое часто не приводит к падению сразу.

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

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

    *p = 99;
    printf("значение = %d\n", *p);

    free(p);
    p = NULL;          // теперь ошибка будет громким падением, а не тихим

    if (p == NULL) {
        printf("p равен null - можно проверять и можно снова вызвать free\n");
    }

    free(p);           // free(NULL) по стандарту ничего не делает, это всегда безопасно
    return 0;
}

Два факта из этого примера стоит запомнить. free(NULL) по определению ничего не делает, поэтому код очистки никогда не нужно этим озабочивать. А присваивание p = NULL после free превращает использование освобождённой памяти — которое может тихо испортить данные — в немедленное и отлаживаемое падение.

Возвращайте NULL в значении «результата нет» и говорите об этом.

// возвращает указатель на подходящий элемент или NULL, если такого нет
int *find(int *arr, int n, int target);

Напишите это в комментарии над функцией. Вызывающий, который знает о возможном NULL, напишет проверку; тот, кто не знает, — нет.

Короткий чек-лист

• Инициализируйте каждый указатель — настоящим адресом или значением NULL.
• Проверяйте возвращаемое значение malloc, calloc, realloc и fopen до его использования.
• Проверяйте параметры-указатели в начале любой функции, которую могут вызвать с некорректным вводом.
• Присваивайте указателям NULL сразу после free.
• Пишите NULL, а не 0, везде, где подразумевается указатель.
• Собирайте с -Wall -Wextra и, когда есть возможность, запускайте под санитайзером: gcc -fsanitize=address,undefined ловит разыменование null с точным отчётом.