Che cosa significa fare un "controllo null" in C o C ++?

Sto imparando il C ++ e sto facendo fatica a capire null. In particolare, i tutorial che ho letto menzionano fare un "controllo null", ma non sono sicuro di cosa significhi o perché sia ​​necessario.

• Che cosa è esattamente null?
• Che cosa significa "controllare null"?
• Devo sempre verificare la presenza di null?

Qualsiasi esempio di codice sarebbe molto apprezzato.

In C e C ++, i puntatori sono intrinsecamente non sicuri, vale a dire, quando si fa riferimento a un puntatore, è responsabilità dell'utente assicurarsi che punti in un punto valido; questo fa parte della "gestione manuale della memoria" (al contrario degli schemi di gestione automatica della memoria implementati in linguaggi come Java, PHP o .NET runtime, che non ti permetteranno di creare riferimenti non validi senza un notevole sforzo).

Una soluzione comune che rileva molti errori è impostare tutti i puntatori che non puntano a nulla come NULL(o, in C ++ corretto 0), e controllarli prima di accedere al puntatore. In particolare, è pratica comune inizializzare tutti i puntatori su NULL (a meno che non si abbia già qualcosa a cui indicarli quando li si dichiarano) e impostarli su NULL quando l'utente deleteo free()loro (a meno che non escano immediatamente dall'ambito di applicazione). Esempio (in C, ma anche C ++ valido):

void fill_foo(int* foo) {
    *foo = 23; // this will crash and burn if foo is NULL
}

Una versione migliore:

void fill_foo(int* foo) {
    if (!foo) { // this is the NULL check
        printf("This is wrong\n");
        return;
    }
    *foo = 23;
}

Senza il controllo null, passare un puntatore NULL in questa funzione causerà un segfault e non c'è nulla che tu possa fare: il sistema operativo semplicemente ucciderà il tuo processo e forse scaricherà il core o aprirà una finestra di dialogo di crash report. Con il controllo null in atto, è possibile eseguire la corretta gestione degli errori e ripristinare con garbo: correggere il problema da soli, interrompere l'operazione corrente, scrivere una voce di registro, informare l'utente, qualunque cosa sia appropriata.

Le altre risposte hanno praticamente coperto la tua domanda esatta. Viene effettuato un controllo nullo per accertarsi che il puntatore ricevuto in realtà punti a un'istanza valida di un tipo (oggetti, primitive, ecc.).

Aggiungerò qui il mio consiglio. Evitare controlli null. :) I controlli nulli (e altre forme di programmazione difensiva) ingombrano il codice e lo rendono effettivamente più soggetto agli errori rispetto ad altre tecniche di gestione degli errori.

La mia tecnica preferita quando si tratta di puntatori a oggetti è quella di utilizzare il modello Null Object . Ciò significa restituire un (puntatore - o ancora meglio, riferimento a un array o elenco vuoto) anziché null, oppure restituire una stringa vuota ("") anziché null, o persino la stringa "0" (o qualcosa di equivalente a "niente "nel contesto) in cui ti aspetti che venga analizzato in un numero intero.

Come bonus, ecco qualcosa che potresti non sapere sul puntatore null, che fu (inizialmente formalmente) implementato da CAR Hoare per la lingua Algol W nel 1965.

Lo chiamo il mio errore da miliardi di dollari. Fu l'invenzione del riferimento nullo nel 1965. A quel tempo, stavo progettando il primo sistema di tipi completo per riferimenti in un linguaggio orientato agli oggetti (ALGOL W). Il mio obiettivo era quello di garantire che ogni uso dei riferimenti fosse assolutamente sicuro, con il controllo eseguito automaticamente dal compilatore. Ma non ho resistito alla tentazione di inserire un riferimento null, semplicemente perché era così facile da implementare. Ciò ha portato a innumerevoli errori, vulnerabilità e arresti anomali del sistema, che probabilmente hanno causato un miliardo di dollari di dolore e danni negli ultimi quarant'anni.

Il valore del puntatore null rappresenta un "nulla" ben definito; è un valore di puntatore non valido che garantisce un confronto diverso da qualsiasi altro valore di puntatore. Tentare di dereferenziare un puntatore nullo comporta un comportamento indefinito e di solito porta a un errore di runtime, quindi si desidera assicurarsi che un puntatore non sia NULL prima di provare a dereferenziarlo. Numerose funzioni di libreria C e C ++ restituiranno un puntatore null per indicare una condizione di errore. Ad esempio, la funzione di libreria mallocrestituirà un valore di puntatore nullo se non è in grado di allocare il numero di byte richiesti e il tentativo di accedere alla memoria tramite quel puntatore (di solito) porterà a un errore di runtime:

int *p = malloc(sizeof *p * N);
p[0] = ...; // this will (usually) blow up if malloc returned NULL

Quindi dobbiamo assicurarci che la mallocchiamata abbia avuto successo controllando il valore di pNULL:

int *p = malloc(sizeof *p * N);
if (p != NULL) // or just if (p)
  p[0] = ...;

Ora, tieniti stretto le calze un minuto, questo diventerà un po 'accidentato.

C'è un valore di puntatore null e una costante di puntatore null e i due non sono necessariamente gli stessi. Il valore del puntatore null è qualunque valore l'architettura sottostante usi per rappresentare "da nessuna parte". Questo valore può essere 0x00000000 o 0xFFFFFFFF o 0xDEADBEEF o qualcosa di completamente diverso. Non dare per scontato che il valore del puntatore null sia sempre 0.

La costante puntatore null , OTOH, è sempre un'espressione integrale con valore 0. Per quanto riguarda il codice sorgente , 0 (o qualsiasi espressione integrale che restituisce 0) rappresenta un puntatore nullo. Sia C che C ++ definiscono la macro NULL come costante puntatore null. Quando viene compilato il codice, la costante puntatore null verrà sostituita con il valore puntatore null appropriato nel codice macchina generato.

Inoltre, tenere presente che NULL è solo uno dei molti possibili valori di puntatore non validi ; se si dichiara una variabile del puntatore automatico senza inizializzarla esplicitamente, ad esempio

int *p;

il valore inizialmente memorizzato nella variabile è indeterminato e potrebbe non corrispondere a un indirizzo di memoria valido o accessibile. Sfortunatamente, non esiste un modo (portatile) per dire se un valore di puntatore non NULL è valido o meno prima di tentare di usarlo. Quindi, se hai a che fare con i puntatori, di solito è una buona idea inizializzarli esplicitamente su NULL quando li dichiari e impostarli su NULL quando non puntano attivamente a nulla.

Si noti che questo è più un problema in C che C ++; il C ++ idiomatico non dovrebbe usare così tanto i puntatori.

Ci sono un paio di metodi, tutti essenzialmente fanno la stessa cosa.

int * foo = NULL; // a volte impostato su 0x00 o 0 o 0L invece di NULL

controllo null (verificare se il puntatore è null), versione A

if (foo == NULL)

controllo null, versione B

if (! foo) // poiché NULL è definito come 0,! foo restituirà un valore da un puntatore null

controllo null, versione C

if (foo == 0)

Dei tre, preferisco usare il primo controllo in quanto dice esplicitamente ai futuri sviluppatori che cosa stavi cercando di controllare E chiarisce che ti aspettavi che Foo fosse un puntatore.

Non L'unico motivo per utilizzare un puntatore in C ++ è perché si desidera esplicitamente la presenza di puntatori null; altrimenti, puoi prendere un riferimento, che è sia semanticamente più facile da usare che garantisce non nullo.

Se non si controlla il valore NULL, in particolare, se si tratta di un puntatore a una struttura, è possibile che si sia verificata una vulnerabilità di sicurezza: la dereferenza del puntatore NULL. La dereferenza del puntatore NULL può portare a alcune altre gravi vulnerabilità della sicurezza come overflow del buffer, condizioni di competizione ... che possono consentire agli aggressori di assumere il controllo del tuo computer.

Molti produttori di software come Microsoft, Oracle, Adobe, Apple ... rilasciano patch software per correggere queste vulnerabilità di sicurezza. Penso che dovresti controllare il valore NULL di ogni puntatore :)