Uso della convalida Assert e del puntatore NULL cosa è meglio usare

Question

Durante la programmazione sto usando assert e convalida del puntatore NULL.

Ma come so assert sarà utile solo nella modalità DEBUG.

La mia domanda è Supponiamo che io sono un puntatore interno che io sono sicuro che posso essere funzione di esempio NULL restituisce un puntatore (ma il puntatore non è un membro della classe) in questi casi posso usare assert

test* ptr = fun(); // return a pointer of type test 
assert(ptr); 

//do some operation 

o NULL pointer convalida

test* ptr = fun(); // return a pointer of type test 
assert(ptr); 
if (NULL != ptr) 
{ 
    //do some operation 
} 

Ecco che pratica il codice è good.As per la mia sottovalutare sarà secondo. Perché ho dovuto affrontare alcune situazioni in cui il valore di ptr restituisce NULL a causa di alcuni casi anomali a cui non possiamo nemmeno pensare.

Ma abbiamo altre opzioni migliori?

Answer 1

La soluzione reale dipende dalla semantica della funzione fun.

Se ritorno NULL è semanticamente valida, allora penso fun dovrebbe generare un'eccezione appropriato (come std::logic_error) invece di tornare NULL, e si potrebbe utilizzare assert sul sito chiamata a garantire che fun sta lavorando bene, e se non funziona bene, quindi interrompere il programma. In questo modo, il bug in fun non si propaga al resto del programma, poiché viene catturato immediatamente.

Tuttavia, se dovessi tornare NULL da fun è semanticamente valida, allora si dovrebbe verificare il valore restituito sulla chiamata in loco utilizzando if e assert non è realmente necessario in questo caso, perché si utilizzerà if comunque.

^{1. Oppure è possibile utilizzare std::runtime_error o std::domain_error.}

Answer 2

Come hai detto, asserisci solo durante il debug, aiutando il programmatore a identificare dove è andato male. Non ha alcun valore in produzione e quindi, preferisco usare il secondo metodo se hai qualche dubbio che il puntatore potrebbe essere NULL.

Answer 3

Ti consiglio di utilizzare il tuo codice per l'asserzione. come hai detto, asserire funziona solo in modalità di debug.

Quindi, se funziona in modalità di rilascio, non funziona.

se si utilizza il proprio codice di asserzione. puoi semplicemente scoprire cosa è sbagliato.

test* ptr = fun(); // return a pointer of type test 
MyOwnAssert(ptr); 

void MyOwnAssert(void* pPointer) 
{ 
    if (NULL == pPointer) 
    abort(); 
}  

Answer 4

assert dice: "Se questo non è vero, v'è un errore logico nel mio codice". Se stai inserendo il codice per gestire il fatto che il puntatore potrebbe essere nullo, allora è la chiamata assert che è ridondante. Dovresti invece aggiungere la registrazione e la gestione al caso 'else'.In questo modo la build di debug verrà eseguita nello stesso modo della build di rilascio, anche nel caso del puntatore nullo.

Se si intende realmente affermare e si deve interrompere un puntatore nullo, abilitare gli asserzioni nella build di rilascio o utilizzare un meccanismo di asserzione abilitato per la versione alternativa.

L'unico motivo per un'asserzione di debug-only è la verifica di un errore logico troppo costoso da realizzare nel codice di rilascio. Normalmente un controllo nullo per un puntatore non si adatta a questa categoria.

Answer 5

Ciò che si fa di affermazione è una scelta personale: è possibile utilizzare è in produzione, se si desidera.

Direi che l'utilizzo di assert() è migliore se si desidera individuare i propri errori in anticipo. Soprattutto se il fatto che si tratta di un puntatore NULL non dovrebbe accadere.
Si può anche inserire un Google Breakpad lì, in modo che ogni volta che si preme un puntatore NULL si invia un report con lo stack completo in quel punto.

Nei casi in cui un puntatore NULL è possibile (e talvolta previsto ...), quindi suppongo che il controllo NULL sia migliore. Ma direi che a questo punto il tuo codice è sbagliato in qualche modo, se deve adattarsi con i puntatori NULL che vengono passati in giro.