In C, NULL è una costante simbolica che punta sempre a un punto inesistente nella memoria. Sebbene molti programmatori lo considerino uguale a 0, questa è una semplificazione che può farti inciampare in seguito. È meglio controllare i tuoi puntatori direttamente contro NULL e usare 0 in altri contesti. Ciò mantiene il tuo codice pulito e facile da capire, poiché saprai che stai lavorando con i puntatori ogni volta che vedi NULL.
Passi
Parte 1 di 2: esecuzione di un controllo nullo
Passaggio 1. Utilizzare il codice di controllo null standard
Quello che segue è il modo più ovvio per scrivere un controllo null. useremo ptr in questo articolo come nome del puntatore che stai controllando.
-
if(ptr == NULL)
{
// codice se il puntatore è NULL
} altro {
// codice se non NULL
}
Passaggio 2. Testare qualsiasi valore tranne NULL
A volte è invece più conveniente testare la disuguaglianza. Nessuna sorpresa qui:
-
if (ptr != NULL) {
// codice se non NULL
}
Passaggio 3. Scrivi prima il NULL per evitare errori (opzionale)
Lo svantaggio principale del metodo PTR == NULL è la possibilità che tu digiti accidentalmente ptr = NULL, assegnando il valore NULL a quel puntatore. Ciò può causare un forte mal di testa. Poiché il test per la (dis)uguaglianza tratta gli operandi in modo simmetrico, puoi ottenere esattamente lo stesso risultato scrivendo if (NULL == ptr) Invece. Questo è più resistente agli errori di battitura, poiché un NULL = ptr accidentale crea un semplice errore di compilazione.
Questo sembra un po' imbarazzante per alcuni programmatori, ma è perfettamente valido. L'approccio che usi dipende solo dalle preferenze personali e da quanto è bravo il tuo compilatore a rilevare l'errore if (ptr = NULL)
Passaggio 4. Verificare se la variabile è vera
Un semplice se (ptr) verifica se ptr è TRUE. Restituirà FALSE se ptr è NULL o se ptr è 0. La distinzione non ha importanza in molti casi, ma tieni presente che non sono identici in tutte le architetture.
Il contrario di questo è se (!ptr), che restituirà TRUE se ptr è FALSE.
Parte 2 di 2: evitare errori
Passaggio 1. Impostare un puntatore prima di verificare NULL
Un errore comune è presumere che un puntatore appena creato abbia un valore NULL. Questo non è vero. Un puntatore non assegnato punta ancora a un indirizzo di memoria, ma non a quello che hai specificato. È pratica comune impostare i puntatori appena creati o appena liberati su NULL per assicurarsi di non utilizzare accidentalmente questo indirizzo inutile.
-
Evita questo errore:
carattere *ptr;
if(ptr == NULL)
{
//Questo restituirà FALSE. Al puntatore è stato assegnato un valore valido.
}
-
Scrivi invece:
carattere *ptr = NULL; //Questo assegna il puntatore a NULL
if(ptr == NULL)
{
//Questo restituirà TRUE se il puntatore non è stato riassegnato.
}
Passaggio 2. Prestare attenzione alle funzioni che potrebbero restituire NULL
Se una funzione può restituire NULL, pensa se questa è una possibilità e se ciò causerebbe problemi più avanti nel tuo codice. Ecco un esempio della funzione malloc che utilizza il controllo null (se (ptr)) per assicurarsi che gestisca solo puntatori con valori validi:
-
int *ptr = malloc(N * sizeof(int));
se (ptr) {
int io;
per (i = 0; i < N; ++i)
ptr = io;
}
Passaggio 3. Comprendi che NULL è 0 ma dovresti sempre usare NULL invece di 0 quando lavori con i puntatori per chiarezza
Storicamente, C rappresentava NULL come numero 0 (ovvero 0x00). Al giorno d'oggi può diventare un po' più complicato e varia in base al sistema operativo. Di solito puoi controllare NULL usando ptr == 0, ma ci sono casi angolari in cui ciò può causare un problema. Forse ancora più importante, l'uso di NULL rende ovvio che stai lavorando con i puntatori per altre persone che leggono il tuo codice.
