Punteros NULL en C: qué significa NULL y cómo comprobarlo

Un puntero siempre guarda algún valor. Cuando todavía no tiene un objeto al que apuntar —antes de que se le asigne, después de que se libere aquello a lo que apuntaba, o cuando una función no tiene nada que devolver— necesita un valor que signifique inequívocamente "aquí no hay nada". Ese valor es el puntero nulo, y NULL es el nombre que escribes.

La disciplina que lo rodea es pequeña y se paga sola constantemente: pon los punteros a NULL cuando no tengan destino, comprueba si son NULL antes de desreferenciarlos y devuelve NULL cuando no tengas resultado.

Qué es NULL en realidad

NULL es una macro, definida en <stddef.h> y arrastrada también por <stdio.h>, <stdlib.h>, <string.h> y otras. Se expande a una constante de puntero nulo, típicamente ((void*)0) o un 0 a secas.

El estándar de C garantiza la propiedad que importa: un puntero nulo resulta distinto de un puntero a cualquier objeto o función real. Dos punteros nulos del mismo tipo siempre resultan iguales entre sí.

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

    return 0;
}

La mayoría de los sistemas imprimen (nil) o 0x0 para el puntero nulo: la dirección cero. Eso es una implementación común, no una regla; el estándar nunca promete que los bits sean cero. Lo que promete es la comparación, así que escribe p == NULL y nunca nada que dependa de la representación.

Desreferenciar NULL revienta

La razón de existir de toda comprobación de nulo:

int *p = NULL;
printf("%d\n", *p);   // comportamiento indefinido: casi con certeza un fallo

En Windows, macOS y Linux la primera página del espacio de direcciones se deja sin mapear a propósito, así que la CPU atrapa el acceso y el sistema operativo mata el programa. Verás:

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

Ese fallo inmediato es una virtud. Convierte un error de lógica en un fallo ruidoso en la línea exacta que lo causó, en lugar de una corrupción silenciosa que descubres tres semanas después. Mira fallo de segmentación para saber cómo leer el fallo y encontrar la línea.

Por eso "puntero nulo" no es una excepción que atrapes en C. No hay mecanismo de recuperación; solo existe comprobar de antemano.

Comprueba lo que puede fallar

Las funciones que pueden fallar lo señalan devolviendo NULL. Comprobarlo no es una cortesía opcional: la alternativa es el fallo.

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

int main(void) {
    // 1. malloc devuelve NULL cuando la reserva falla
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "memoria agotada\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("reserva correcta: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. strchr devuelve NULL cuando no encuentra el caracter
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("se encontro 'w' en el indice %td\n", found - text);
    }

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

    return 0;
}

La biblioteca estándar está llena de estas: malloc, calloc, realloc, fopen, strchr, strstr, getenv, bsearch. Todas responden "sin resultado" con NULL. Mira memoria dinámica para la historia completa de las reservas.

Dos modismos para la comprobación, ambos comunes:

if (p == NULL) { /* manejarlo */ }   // explicito: preferible por claridad
if (!p)        { /* manejarlo */ }   // breve: se apoya en que NULL es falso

Un puntero nulo se evalúa como falso en una condición y uno válido como verdadero, así que ambos funcionan. La forma explícita se lee mejor cuando alguien ajeno revisa tu código en busca de errores.

NULL frente a 0 frente a sin inicializar

Tres situaciones distintas que los principiantes mezclan:

int *a = NULL;     "no apunta a nada": comprobable, seguro de revisar
int *b;            sin inicializar: guarda basura, NO es comprobable
int *c = &x;       apunta a un objeto real

El peligroso es b. Sus bytes son lo que hubiera quedado en ese hueco de la pila, que podría ser cero (y parecer correcto) o podría ser una dirección con pinta plausible de una llamada anterior. Ninguna comprobación puede distinguirlo de un puntero válido, y el comportamiento cambia entre compilaciones de depuración y de lanzamiento.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // definitivamente nada

    if (safe == NULL) {
        printf("safe es nulo: esto si podemos comprobarlo\n");
    }

    // un puntero sin inicializar no se puede comprobar; la solucion es no tener uno
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed empieza en nulo\n");
        fixed = &value;
    }
    printf("fixed ahora apunta a %d\n", *fixed);

    return 0;
}

Inicializa todos los punteros. Si todavía no tienes ninguna dirección, NULL es la dirección. Compila con -Wall -Wextra y el compilador señalará muchos usos sin inicializar por ti.

Sobre el 0: en un contexto de puntero la constante entera 0 es la constante de puntero nulo, así que p = 0; es C válido. Prefiere NULL igualmente. Señala la intención, e importa en las llamadas variádicas donde el compilador no puede convertir por ti:

execl("/bin/ls", "ls", 0);              // arriesgado: puede pasar un int donde se espera un puntero
execl("/bin/ls", "ls", (char *)NULL);   // correcto

C23 agrega nullptr, una palabra clave con su propio tipo que evita por completo esta clase de ambigüedad; NULL sigue siendo correcto y portable en todas partes.

Patrones defensivos

Protege al inicio de una función que recibe punteros.

#include <stdio.h>

// devuelve 0 si tuvo exito, distinto de cero si la entrada es mala
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // rechazar en lugar de reventar
    }
    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("promedio = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("se rechazo un array NULL en vez de reventar\n");
    }

    return 0;
}

Pon el puntero a NULL después de liberar. free no cambia tu puntero: solo libera la memoria. El puntero rancio que queda es un puntero colgante, y usarlo es comportamiento indefinido que a menudo no revienta enseguida.

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

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

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

    free(p);
    p = NULL;          // ahora el error es un fallo ruidoso, no uno silencioso

    if (p == NULL) {
        printf("p es nulo: seguro de comprobar, seguro de liberar otra vez\n");
    }

    free(p);           // free(NULL) es explicitamente inofensivo, siempre seguro
    return 0;
}

Dos hechos dentro de ese ejemplo merecen memorizarse. free(NULL) está definido para no hacer nada, así que el código de limpieza nunca necesita protegerlo. Y poner p = NULL después de free convierte un uso tras liberación —que puede corromper datos en silencio— en un fallo inmediato y depurable.

Devuelve NULL para decir "sin resultado", y dilo.

// devuelve un puntero al elemento coincidente, o NULL si no hay ninguno
int *find(int *arr, int n, int target);

Documéntalo en el comentario encima de la función. Quien llama y sabe que un NULL es posible escribe la comprobación; quien no lo sabe, no la escribirá.

Una lista rápida

• Inicializa todos los punteros, con una dirección real o con NULL.
• Comprueba el retorno de malloc, calloc, realloc y fopen antes de usarlo.
• Comprueba los parámetros de tipo puntero al inicio de cualquier función que pueda llamarse con entrada mala.
• Pon los punteros a NULL inmediatamente después de free.
• Escribe NULL, no 0, siempre que quieras decir un puntero.
• Compila con -Wall -Wextra y, cuando puedas, ejecuta bajo un sanitizador: gcc -fsanitize=address,undefined detecta las desreferencias nulas con un informe preciso.