Nested If (x) checks - Modo migliore per scrivere questo?

Question

Ci sono luoghi in cui controllo i puntatori validi prima di eseguire un'operazione con essi; questi controlli possono essere annidati abbastanza profondamente a volte.

Ad esempio, ho

if (a) 
{ 
    if (a->b()) 
    { 
    if (a->b()->c()) 
    { 
     a->b()->c()->DoSomething(); 
    } 
    } 
} 

Io davvero non mi piace l'aspetto di questo. C'è un modo per trasformare questo in qualcosa di più leggibile? Idealmente,

if (a && a->b() && a->b()->c()) 
{ 
... 
} 

sarebbe fantastico, ma ovviamente non funzionerebbe.

EDIT - nvm l'esempio che ho messo funziona come tutti hanno sottolineato. L'ho provato per vedere se funziona, ma c'era un bug nel mio codice nel mio test. duh!

Answer 1

Perché quest'ultimo non funziona?

In C, & & & è un operatore di cortocircuito, quindi viene valutato da sinistra a destra e, se una valutazione è falsa, la valutazione si interrompe.

In realtà, si potrebbe scrivere:

a && a->b() && a->b()->c() && a->b()->c()->DoSomething(); 

Answer 2

tuo secondo esempio funziona in C/C++. Si mette in corto circuito quando viene colpito il primo valore FALSE.

Answer 3

Perché 'ovviamente non funzionerebbe'? Poiché l'operatore && valuta solo il termine corretto se la sinistra è valida, la riscrittura è perfettamente sicura.

Answer 4

Citando K&R :

Espressioni collegati da && o || vengono valutati da sinistra a destra, ed è garantito che la valutazione si fermerà non appena la verità o falsità è noto.

Pertanto, l'ultimo esempio funzionerà perfettamente, come WhirlWind has noted.

---

The C Programming Language, seconda edizione, pagina 21.

Answer 5

if (a && a->b() && a->b()->c()) { a->b()->c()->DoSomething(); }

C++ esegue la valutazione pigra modo questo funzionerà. Innanzitutto, verrà valutato e se è 0 l'intera condizione è falsa, quindi non ci sarà alcuna valutazione delle altre parti.

Questo funziona anche per l'operatore ||. Se scrivi if (a || b), b non verrà valutato se a è vero.

Answer 6

Hai visto dalle altre risposte che l'utilizzo di & & funzionerà e cortocircuiterà la valutazione quando viene rilevato un puntatore nullo.

Il programmatore inquieto in me ama evitare di ripetere le chiamate di metodo per test come questo poiché evita di preoccuparsi se sono idempotenti o meno.Una possibilità è quella di riscrivere come questo

A* a; 
B* b; 
C* c; 

if ((a=a()) && (b=a->b()) && (c=b->c())) { 
    c->doSomething(); 
} 

Certo prolisso e un po 'goffo, ma almeno si sa ogni metodo viene chiamato solo una volta.

Answer 7

Secondo funzionerà se si desidera chiamare solo DoSomething().

Answer 8

Dato che hai già ricevuto la risposta diretta alla tua domanda, ti accennerò semplicemente che le lunghe catene di chiamate come quelle che hai ricevuto sono un odore di codice e potresti considerare un design migliore. un tale progetto potrebbe, in questo caso, includere l'uso del modello oggetto null in modo che la chiamata potrebbe anche ridursi a:

a->CDoSomething(); 

Answer 9

opere concatenamento, ma non è necessariamente la migliore risposta generale e minuscole, soprattutto perché oscura il punto di errore. Vorrei invece suggerire di appiattire i test invertendo la logica in modo che esca in caso di fallimento.

if (!pa) 
    return Fail("No pa"); 

B* pb = pa->b(); 
if (!pb) 
    return Fail("No pb"); 

C* pc = b->c(); 
if (!pc) 
    return Fail("No pc"); 

pc->DoSomething(); 

Stessa cosa, ma piatta e facile da leggere. Inoltre, poiché gestisce immediatamente il caso di errore, questo non viene relegato a un else che potresti non riuscire mai a scrivere.

In questo esempio, ho pensato che non volessi semplicemente fallire, quindi ho aggiunto Fail come aiuto che registra il testo e restituisce false. Potresti anche solo lanciare un'eccezione. Infatti, se i vari metodi segnalavano il loro fallimento lanciando un'eccezione appropriata invece di restituire nulla, allora tutto ciò non sarebbe necessario. Se fosse auspicabile un errore silenzioso, sarebbe opportuno un modello di oggetto nullo.