C Ponteiro Nulo (NULL e nullptr)

Na aula Ponteiros você viu que um ponteiro sem valor inicial guarda lixo, um endereço qualquer, e que isso é perigoso. Mas às vezes você ainda não tem para onde apontar: a pessoa não escolheu uma opção, a busca não achou nada, o arquivo não abriu. Para isso existe o ponteiro nulo: um valor especial que quer dizer "não aponta para nada", e que dá para testar. Esta aula mostra como criá-lo, como conferir antes de usar e o que acontece quando alguém esquece de conferir.

Os programas foram compilados na máquina da Ana, na pasta ~/c, com gcc -std=c23 -Wall -Wextra arquivo.c -o programa.

A ideia: o bilhete em branco

Lembra do bilhete com o número da gaveta? Existem três situações possíveis para ele:

O ponteiro nulo é o terceiro bilhete. Ele não resolve tudo sozinho: ir até a gaveta "NENHUMA" continua sendo um erro. A vantagem é que esse erro pode ser evitado com um if, e, quando não é evitado, o programa morre na hora e no lugar certo, em vez de estragar dados em silêncio.

1. Criar e testar um ponteiro nulo

#include <stdio.h>

int main(void) {
    int *p = NULL;

    printf("p guarda %p\n", (void *) p);
    if (p == NULL) {
        printf("p não aponta para nada\n");
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra nulo.c -o nulo
$ ./nulo
p guarda (nil)               « o jeito da glibc de mostrar o ponteiro nulo
p não aponta para nada

int *p = NULL;

Cria o ponteiro já "apontando para nada". NULL (lê-se "nul") é uma constante que vem nos cabeçalhos da biblioteca padrão. O stdio.h já a traz, por isso este programa não precisou de outro #include.

p == NULL

Compara o endereço guardado em p com o nulo. Repare: sem *. Você pergunta sobre o bilhete, sem ir até gaveta nenhuma.

(nil)

É assim que o %p da glibc (a biblioteca C do Linux) mostra um ponteiro nulo: "nil", nada. No editor do guia, que usa outra biblioteca, o mesmo programa mostra p guarda 0.

Por dentro, o nulo é o endereço 0

Na prática, NULL é o endereço zero, uma gaveta que o sistema nunca entrega a programa nenhum. Por isso escrever int *q = 0; também cria um ponteiro nulo, e um ponteiro nulo vale "falso" num if:

#include <stdio.h>

int main(void) {
    int *p = NULL;
    int *q = 0;
    int x = 5;
    int *r = &x;

    printf("p == q? %d\n", p == q);
    printf("p é falso? %d\n", !p);
    printf("r é falso? %d\n", !r);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra zero.c -o zero
$ ./zero
p == q? 1          « NULL e 0 dão o mesmo ponteiro
p é falso? 1       « nulo conta como falso
r é falso? 0       « um ponteiro que aponta para algo conta como verdadeiro

Daí vem a forma curta de testar, muito comum em código C:

As duas fazem exatamente o mesmo. A forma longa é mais clara para quem está começando; a curta é a que você mais vai encontrar em projetos.

2. nullptr: o nulo do C23 C23

O C23 criou uma palavra-chave própria para o ponteiro nulo, nullptr (de "null pointer", ponteiro nulo), que não precisa de #include nenhum. O gcc 15 e o Clang do editor aceitam:

#include <stdio.h>

int main(void) {
    int *p = nullptr;

    if (p == nullptr) {
        printf("p é nulo\n");
    }
    printf("p == NULL? %d\n", p == NULL);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra nullptr.c -o nullptr
$ ./nullptr
p é nulo
p == NULL? 1           « nullptr e NULL dão o mesmo ponteiro nulo

Por que criar outra forma, se NULL já existia? Porque NULL é uma macro, e cada biblioteca a define de um jeito: às vezes como ((void *)0), às vezes como um simples 0. Um 0 também é um número inteiro, e isso causa confusões em situações avançadas (como nas funções variádicas, as de número variável de argumentos, como o próprio printf). O nullptr é sempre e só um ponteiro nulo, com um tipo próprio, nullptr_t.

O preço: só existe a partir do C23. Com um padrão mais antigo, ele não é reconhecido:

$ gcc -std=c17 -Wall -Wextra nullptr.c -o nullptr
nullptr.c: In function ‘main’:
nullptr.c:4:14: error: ‘nullptr’ undeclared (first use in this function)
    4 |     int *p = nullptr;
      |              ^~~~~~~
nullptr.c:4:14: note: each undeclared identifier is reported only once for each function it appears in

3. Ir até a gaveta "NENHUMA": desreferenciar o nulo

Testar p é seguro. Usar *p quando p é nulo, não: é ir até a gaveta zero, que não pertence ao programa.

#include <stdio.h>

int main(void) {
    int *p = NULL;

    printf("Antes de usar o ponteiro\n");
    printf("*p vale %d\n", *p);
    printf("Depois\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra desref.c -o desref
$ ./desref
Antes de usar o ponteiro
Falha de segmentação     (imagem do núcleo gravada) ./desref
$ echo $?
139

Compilou sem nenhum aviso, rodou a primeira linha e morreu na segunda. Vamos ler a mensagem, que é do terminal (o bash), não do seu programa:

Falha de segmentação

Em inglês, segmentation fault ("segfault"). O programa tentou mexer numa região da memória (um "segmento") que não é dele, e o sistema o matou na hora.

(imagem do núcleo gravada)

Em inglês, core dumped. O sistema pode salvar uma "fotografia" da memória do programa no momento da morte, para estudar depois com um depurador. Você não precisa fazer nada com ela agora; a aula Depurar com gdb mostra outro jeito de investigar.

./desref

Qual comando morreu.

139

O código de saída. Quando um programa é morto por um sinal, o código é 128 + o número do sinal. A falha de segmentação é o sinal 11 (SIGSEGV): 128 + 11 = 139. Veja Sinais.

No editor do guia, o resultado é o mesmo: a saída mostra Antes de usar o ponteiro, depois Falha de segmentação (imagem do núcleo gravada) e [código de saída: 139]. Experimente:

#include <stdio.h>

int main(void) {
    int x = 42;
    int *p = NULL;

    printf("x vale %d\n", x);
    printf("Antes de usar o ponteiro\n");
    printf("*p vale %d\n", *p);
    printf("Depois\n");
    return 0;
}

A saída que some: o buffer do printf

Agora rode o mesmo programa mandando a saída para um arquivo, em vez da tela:

$ ./desref > saida.txt
Falha de segmentação     (imagem do núcleo gravada) ./desref > saida.txt
$ cat saida.txt
$                            « o arquivo está vazio!

O Antes de usar o ponteiro sumiu. O motivo: o printf não escreve cada letra na hora. Ele junta o texto num buffer (um balde) e só despeja o balde de tempos em tempos, porque despejar de uma vez é muito mais rápido. A regra da glibc é:

• Se a saída é a tela (um terminal), o balde é despejado a cada \n. Por isso, no terminal, a primeira linha apareceu.
• Se a saída é um arquivo ou um pipe (|), o balde só é despejado quando enche (alguns milhares de letras) ou quando o programa termina normalmente.

Um programa morto por falha de segmentação não termina normalmente: o balde vai junto com ele, sem ser despejado. Isso engana muita gente, que procura o erro no lugar errado ("se nem o primeiro printf apareceu, o erro deve estar antes dele!"). Duas defesas:

• fflush(stdout); logo depois de um printf força o despejo do balde.
• Mensagens de depuração vão para stderr, que não tem balde: fprintf(stderr, "chegou aqui\n"); (veja stdin, stdout e stderr).

Descobrir a linha do erro

A mensagem Falha de segmentação não diz onde o programa morreu. Num programa grande, a forma mais rápida de descobrir é compilar com o AddressSanitizer (-fsanitize=address) e -g, que acrescentam ao programa um "fiscal" da memória:

$ gcc -std=c23 -Wall -Wextra -g -fsanitize=address desref.c -o desref-asan
$ ./desref-asan
Antes de usar o ponteiro
AddressSanitizer:DEADLYSIGNAL
=================================================================
==58052==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x59e405ebe267 bp 0x7ffe3dcbd470 sp 0x7ffe3dcbd460 T0)
==58052==The signal is caused by a READ memory access.
==58052==Hint: address points to the zero page.
    #0 0x59e405ebe267 in main /home/ana/c/desref.c:7
    #1 0x77d13c82a600 in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:59
    #2 0x77d13c82a717 in __libc_start_main_impl ../csu/libc-start.c:360
    #3 0x59e405ebe144 in _start (/home/ana/c/desref-asan+0x1144) (BuildId: ad68b35b2bf9594f8e02e5ad0bf5bd7c00457bab)
…                            « (os valores dos registradores do processador, omitidos aqui)
SUMMARY: AddressSanitizer: SEGV /home/ana/c/desref.c:7 in main
==58052==ABORTING

As linhas importantes: SEGV on unknown address 0x000000000000 (falha de segmentação no endereço zero, o nulo), READ memory access (foi uma leitura), address points to the zero page (o endereço está na "página zero", a do nulo) e, principalmente, desref.c:7: linha 7, a do *p. O sanitizer não funciona no editor do guia; a aula Sanitizers mostra mais.

4. Sempre conferir antes de usar

O uso típico do ponteiro nulo: um ponteiro que talvez receba um endereço. Ele nasce nulo, alguma decisão do programa pode apontá-lo para algo, e, antes de usar, você confere. A Ana quer ver os pontos de uma pessoa do jogo:

#include <stdio.h>

int main(void) {
    int pontos_ana = 30;
    int pontos_bia = 45;
    int *escolhido = NULL;
    int opcao = 0;

    printf("Ver os pontos de quem? (1 = Ana, 2 = Bia): ");
    if (scanf("%d", &opcao) != 1) {
        printf("Digite um número.\n");
        return 1;
    }

    if (opcao == 1) {
        escolhido = &pontos_ana;
    } else if (opcao == 2) {
        escolhido = &pontos_bia;
    }

    if (escolhido != NULL) {
        printf("Pontos: %d\n", *escolhido);
    } else {
        printf("Opção inválida.\n");
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra escolha.c -o escolha
$ ./escolha
Ver os pontos de quem? (1 = Ana, 2 = Bia): 2
Pontos: 45
$ ./escolha
Ver os pontos de quem? (1 = Ana, 2 = Bia): 7
Opção inválida.          « nenhum if apontou o ponteiro: ele continuou NULL

Esse padrão vai aparecer o tempo todo, porque muitas funções da biblioteca padrão devolvem NULL quando falham: fopen quando o arquivo não abre (Arquivos), malloc quando falta memória (malloc e free), strchr quando não acha a letra (Funções de String), getenv quando a variável não existe (getenv), fgets quando a entrada acaba (fgets). Em todas, a regra é a mesma: confira o retorno antes de usar.

Conferir e usar na mesma condição

O && só olha o lado direito se o esquerdo for verdadeiro (veja Operadores Lógicos). Por isso esta linha é segura, mesmo quando p é nulo:

if (p != NULL && *p > 0) {     // se p for nulo, o *p nem é avaliado
    printf("positivo\n");
}

Inverter a ordem (*p > 0 && p != NULL) estraga tudo: o *p seria avaliado primeiro.

Ver os pontos de quem? (1 = Ana, 2 = Bia): 7
Opção inválida.

#include <stdio.h>

int main(void) {
    int pontos_ana = 30;
    int pontos_bia = 45;
    int *escolhido = NULL;
    int opcao = 0;

    printf("Ver os pontos de quem? (1 = Ana, 2 = Bia): ");
    if (scanf("%d", &opcao) != 1) {
        printf("Digite um número.\n");
        return 1;
    }

    if (opcao == 1) {
        escolhido = &pontos_ana;
    } else if (opcao == 2) {
        escolhido = &pontos_bia;
    }

    printf("Pontos: %d\n", *escolhido);
    return 0;
}

#include <stdio.h>

int main(void) {
    int pontos_ana = 30;
    int pontos_bia = 45;
    int *escolhido = NULL;
    int opcao = 0;

    printf("Ver os pontos de quem? (1 = Ana, 2 = Bia): ");
    if (scanf("%d", &opcao) != 1) {
        printf("Digite um número.\n");
        return 1;
    }

    if (opcao == 1) {
        escolhido = &pontos_ana;
    } else if (opcao == 2) {
        escolhido = &pontos_bia;
    }

    if (escolhido != NULL) {
        printf("Pontos: %d\n", *escolhido);
    } else {
        printf("Opção inválida.\n");
    }
    return 0;
}

Hábitos que evitam o problema

1. Todo ponteiro nasce com valor: o endereço de algo, ou NULL. Nunca int *p; sozinho.
2. Confira antes de usar todo ponteiro que pode ser nulo, principalmente os que vêm de funções (fopen, malloc, strchr…).
3. Depois de "jogar fora" o que o ponteiro apontava, volte-o para NULL. Isso fará sentido em malloc e free: um ponteiro para memória já devolvida parece válido, mas não é; um nulo, pelo menos, dá para testar.
4. Compile com -Wall -Wextra e, quando um programa morrer sem explicação, rode-o com -g -fsanitize=address.

Quando dá errado

int main(void) {
    int *p = NULL;
    return p == 0;
}

$ gcc -std=c23 -Wall -Wextra semnull.c -o semnull
semnull.c: In function ‘main’:
semnull.c:2:14: error: ‘NULL’ undeclared (first use in this function)
    2 |     int *p = NULL;
      |              ^~~~
semnull.c:1:1: note: ‘NULL’ is defined in header ‘<stddef.h>’; this is probably fixable by adding ‘#include <stddef.h>’
  +++ |+#include <stddef.h>
    1 | int main(void) {
semnull.c:2:14: note: each undeclared identifier is reported only once for each function it appears in
    2 |     int *p = NULL;
      |              ^~~~

$ gcc -std=c17 -Wall -Wextra nullptr.c -o nullptr
nullptr.c: In function ‘main’:
nullptr.c:4:14: error: ‘nullptr’ undeclared (first use in this function)
    4 |     int *p = nullptr;
      |              ^~~~~~~
nullptr.c:4:14: note: each undeclared identifier is reported only once for each function it appears in

$ gcc -std=c23 -Wall -Wextra escolha-sem.c -o escolha-sem
$ echo 7 | ./escolha-sem
Falha de segmentação     (imagem do núcleo gravada) echo 7 | ./escolha-sem
$ echo $?
139

Referência rápida

Exercícios

Missão final: achou ou não achou?

Primeiro negativo: -15
Depois: 120 80 0 40 -3

#include <stdio.h>

int main(void) {
    int saldos[5] = {120, 80, -15, 40, -3};
    int *achado = NULL;

    for (int i = 0; i < 5; i++) {
        // se saldos[i] for negativo: aponte achado para ele e pare
    }

    // confira achado: mostre o valor e zere pelo ponteiro,
    // ou mostre "Nenhum negativo"

    printf("Depois:");
    for (int i = 0; i < 5; i++) {
        printf(" %d", saldos[i]);
    }
    printf("\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    int saldos[5] = {120, 80, -15, 40, -3};
    int *achado = NULL;

    for (int i = 0; i < 5; i++) {
        if (saldos[i] < 0) {
            achado = &saldos[i];
            break;
        }
    }

    if (achado != NULL) {
        printf("Primeiro negativo: %d\n", *achado);
        *achado = 0;
    } else {
        printf("Nenhum negativo\n");
    }

    printf("Depois:");
    for (int i = 0; i < 5; i++) {
        printf(" %d", saldos[i]);
    }
    printf("\n");
    return 0;
}

Resumo

• O ponteiro nulo não aponta para nada, e, ao contrário do lixo, dá para testar.
• NULL vem dos cabeçalhos padrão (stddef.h, stdio.h, stdlib.h…) e funciona em qualquer C. nullptr é a palavra-chave do C23, sem cabeçalho.
• Teste com if (p != NULL) ou if (p); nulo vale falso.
• Desreferenciar o nulo (*p) mata o programa: Falha de segmentação (imagem do núcleo gravada), código 139, no Linux e no editor.
• Quando o programa morre, o que estava no balde do printf some (principalmente com a saída num arquivo ou pipe). Use fflush(stdout) ou stderr para mensagens de depuração, e -g -fsanitize=address para achar a linha.
• Funções como fopen, malloc, strchr e getenv devolvem NULL quando falham: confira sempre. Próxima aula: Ponteiros e Arrays.