0Pricing
C++ Academy · Aula

nullptr e segurança de ponteiros nulos

Use nullptr em vez de NULL ou 0 e evite desreferenciações de ponteiros nulos

nullptr e segurança de ponteiros nulos é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

O que é um ponteiro nulo?

Um ponteiro nulo é um valor especial que aponta para "nada". Desreferenciá-lo é comportamento indefinido — normalmente causa uma falha de segmentação.

nullptr no C++ moderno

Desde o C++11, a palavra-chave nullptr representa um literal de ponteiro nulo tipado. Prefira-o a NULL ou 0.

int* p1 = nullptr;
int* p2 = NULL;       // legacy macro
int* p3 = 0;          // legacy literal

Por que usar nullptr?

NULL é apenas uma macro para 0. Isso pode confundir a resolução de sobrecargas entre int e int*. nullptr tem o tipo exclusivo std::nullptr_t.

void f(int);
void f(int*);

f(NULL);      // calls f(int) -- surprising!
f(nullptr);   // calls f(int*) -- correct

Verificando se é nulo

Os ponteiros são convertidos implicitamente para bool: um ponteiro não nulo é verdadeiro, e um ponteiro nulo é falso.

if (p) std::cout << "has value\n";
if (!p) std::cout << "is null\n";
if (p != nullptr) std::cout << "explicit form\n";

Inicialize sempre

Ponteiros não inicializados contêm lixo e aparentam apontar para algum lugar. Sempre os inicialize, mesmo que seja apenas com nullptr.

int* p;            // BAD: undefined contents
int* q = nullptr;  // GOOD

Desreferenciando um ponteiro nulo

Ler ou escrever por meio de um ponteiro nulo é comportamento indefinido. Na maioria dos sistemas de computador, isso causa uma falha de segmentação. Em dispositivos embarcados, pode corromper a memória silenciosamente.

Verificações defensivas

Verifique antes de desreferenciar em APIs públicas ou quando o chamador puder passar um valor nulo.

void process(int* data) {
    if (!data) return;
    *data *= 2;
}

Referências em vez de ponteiros

Se o valor nulo nunca for significativo, use um parâmetro de referência. O compilador garante que a referência esteja vinculada a algo.

// Before
void f(Widget* w);   // can be null?

// After
void f(Widget& w);   // must be a real widget

std::optional para valores opcionais

O C++17 adicionou std::optional<T> para a semântica de "talvez um valor" — mais clara que um ponteiro que pode ser nulo em contextos que não envolvem alocação.

#include <optional>
std::optional<int> find(int x);
if (auto v = find(42)) std::cout << *v;

Ponteiros inteligentes e valores nulos

std::unique_ptr e std::shared_ptr também podem ser nulos. Eles são convertidos para bool em verificações e são redefinidos com = nullptr.

Armadilha: ponteiro pendente após delete

Após delete p, o ponteiro ainda contém o endereço antigo. Redefina-o: p = nullptr;. Os ponteiros inteligentes fazem isso automaticamente.

Verificação rápida

Qual literal de ponteiro nulo deve ser usado no C++ moderno?

Recapitulação

Use nullptr para valores de ponteiro nulo. Sempre inicialize os ponteiros. Verifique antes de desreferenciar ou, melhor ainda, use referências e std::optional quando o valor nulo nunca for válido.

Perguntas Frequentes

A aula “nullptr e segurança de ponteiros nulos” é grátis?

Sim — o texto completo de “nullptr e segurança de ponteiros nulos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “nullptr e segurança de ponteiros nulos”?

Use nullptr em vez de NULL ou 0 e evite desreferenciações de ponteiros nulos Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “nullptr e segurança de ponteiros nulos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Ponteiros brutos e o operador de obtenção de endereço
  2. Desreferenciação e aritmética de ponteiros
  3. nullptr e segurança de ponteiros nulos
  4. Quando usar ponteiros versus referências
← Voltar para C++ Academy