Em C, NULL é uma constante simbólica que sempre aponta para um ponto inexistente na memória. Embora muitos programadores o tratem como igual a 0, esta é uma simplificação que pode confundi-lo mais tarde. É melhor comparar seus ponteiros diretamente com NULL e usar 0 em outros contextos. Isso mantém seu código limpo e fácil de entender, pois você saberá que está trabalhando com ponteiros sempre que vir NULL.
Passos
Parte 1 de 2: Executando uma verificação nula
Etapa 1. Use o código de verificação nulo padrão
A seguir está a maneira mais óbvia de escrever uma verificação de nulo. Vamos usar ptr neste artigo como o nome do ponteiro que você está verificando.
-
if (ptr == NULL)
{
// codificar se o ponteiro for NULL
} outro {
// codifique se não for NULL
}
Etapa 2. Teste qualquer valor, exceto NULL
Às vezes, é mais conveniente testar a desigualdade. Sem surpresas aqui:
-
if (ptr! = NULL) {
// codificar se não for NULL
}
Etapa 3. Escreva o NULL primeiro para evitar erros (opcional)
A principal desvantagem do método PTR == NULL é a chance de você digitar acidentalmente ptr = NULL, atribuindo o valor NULL a esse ponteiro. Isso pode causar uma grande dor de cabeça. Uma vez que o teste de (in) igualdade trata os operandos simetricamente, você pode obter exatamente o mesmo resultado escrevendo if (NULL == ptr) em vez de. Isso é mais resistente a erros de digitação, pois um NULL = ptr acidental cria um erro de compilação simples.
Isso parece um pouco estranho para alguns programadores, mas é perfeitamente válido. A abordagem que você usa depende apenas da preferência pessoal e de quão bom é o seu compilador em detectar o erro if (ptr = NULL)
Etapa 4. Teste se a variável é verdadeira
Um simples if (ptr) testa se ptr é TRUE. Ele retornará FALSE se ptr for NULL ou se ptr for 0. A distinção não importa em muitos casos, mas esteja ciente de que eles não são idênticos em todas as arquiteturas.
O reverso disso é if (! ptr), que retornará TRUE se ptr for FALSE.
Parte 2 de 2: evitando erros
Etapa 1. Defina um ponteiro antes de verificar se há NULL
Um erro comum é presumir que um ponteiro recém-criado tem um valor NULL. Isso não é verdade. Um ponteiro não atribuído ainda aponta para um endereço de memória, apenas não aquele que você especificou. É uma prática comum definir ponteiros recém-criados ou liberados como NULL para ter certeza de não usar este endereço inútil por acidente.
-
Evite este erro:
char * ptr;
if (ptr == NULL)
{
// Isso retornará FALSE. O ponteiro recebeu um valor válido.
}
-
Em vez disso, escreva:
char * ptr = NULL; // Isso atribui o ponteiro para NULL
if (ptr == NULL)
{
// Isso retornará TRUE se o ponteiro não tiver sido reatribuído.
}
Etapa 2. Preste atenção às funções que podem retornar NULL
Se uma função puder retornar NULL, pense se isso é uma possibilidade e se isso causaria problemas posteriormente em seu código. Aqui está um exemplo da função malloc usando a verificação de nulo (if (ptr)) para garantir que ele manipule apenas ponteiros com valores válidos:
-
int * ptr = malloc (N * sizeof (int));
if (ptr) {
int i;
para (i = 0; i <N; ++ i)
ptr = i;
}
Etapa 3. Entenda que NULL é 0, mas você deve sempre usar NULL em vez de 0 ao trabalhar com ponteiros para maior clareza
Historicamente, C representava NULL como o número 0 (ou seja, 0x00). Hoje em dia isso pode ficar um pouco mais complicado e varia de acordo com o sistema operacional. Normalmente, você pode verificar se há NULL usando ptr == 0, mas existem casos extremos em que isso pode causar um problema. Talvez mais importante, usar NULL torna óbvio que você está trabalhando com ponteiros para outras pessoas lendo seu código.
