Diversi stili di flusso del programma?

Question

Sono uno studente di informatica quindi non lo so molto.

Recentemente stavo parlando con un amico che ha appena ottenuto un lavoro come sviluppatore di software (Java). Mi ha detto che nel suo lavoro c'è un ragazzo che ha davvero esperienza in C++, ma sfortunatamente ogni volta che scrive codice in java, sta usando il try-catch per controllare il flusso del programma. Secondo il mio amico questo è uno stile sbagliato in Java. È vero? Quali sono le differenze (se ce ne sono) nell'usare try-catch (-finalmente in java) tra C++ e Java?

Answer 1

L'uso di try-catch per controllare il flusso del programma è sbagliato ovunque ... La gestione delle eccezioni è quello che dice: Gestione delle circostanze eccezionali.

Ovviamente per ogni regola ci sono una dozzina di contro-esempi di deviazioni necessarie, ma in generale: non controllare il flusso del programma con eccezioni.

L'utilizzo di eccezioni per il controllo del flusso di un programma si verifica quando si anticipano determinate eccezioni generate in un normale ambiente operativo e si prendono decisioni logiche in base a tali eccezioni.

Ad esempio controllare il flusso del programma in pseudo-codice:

try { 
    write update to file 
} catch (IOException) { 
    write update to alternate file 
} 

In questo caso sarebbe meglio provare effettivamente per il percorso esistenza prima di eseguire ciecamente la scrittura.

ho tolto il permesso di controllare le note perché è un cattivo esempio

Un buon utilizzo di gestione delle eccezioni: (pseudo codice di nuovo)

try { 
    do stuff 
} catch(OutOfMemoryException) { 
    fail gracefully (don't try and do something else to achieve the same result) 
} 

Answer 2

La tua domanda è troppo vaga senza codice di esempio. Non c'è finally in C++.

EDIT In generale, non si desidera utilizzare exceptions come mezzo per controllare il flusso. Exceptions devono essere utilizzati solo per casi eccezionali (situazioni impreviste).

Answer 3

Direi che dal punto di vista dell'architettura del programma lo scopo delle eccezioni è lo stesso in Java e C++. Dovrebbero essere usati per gestire casi eccezionali, non il diretto flusso normale del programma.

L'argomento più comune contro l'utilizzo di eccezioni è che sono lenti. Come la maggior parte degli argomenti basati sulla velocità del codice, oggigiorno è quasi sempre irrilevante, specialmente quando le eccezioni vengono utilizzate correttamente.

Answer 4

mi aspetterei il mondo Java C++ e ad essere in gran parte simili nei loro punti di vista:

1. controllo del flusso con blocchi try/catch non è immediatamente evidente
2. è costoso prestazioni-saggio. In pratica, questo potrebbe non essere un problema, ma in molti scenari (ad esempio i loop stretti) ti avrà sicuramente un impatto.

Answer 5

Penso che quello che sta dicendo è che sta usando le eccezioni per condizioni non eccezionali come le normali terminazioni del ciclo.Questo è considerato un no-no dai programmatori nella maggior parte delle lingue che forniscono eccezioni, incluso C++.

Il motivo è che le eccezioni tendono a trascinare con sé un bel po 'di informazioni. Su alcune piattaforme, portano l'intero callstack al punto dell'eccezione, allo scopo di visualizzarlo in un messaggio di debug bello. È molto costoso, se tutto quello che vuoi veramente è un salto di controllo incondizionato.

Invece, si dovrebbero usare istruzioni come break, return o anche (in un vero pizzico) goto.

Answer 6

Il blocco try-catch è destinato a fare la stessa cosa in tutte le lingue - le eccezioni sono uno dei molti modi di recupero quando qualcosa va storto. In Java, le seguenti due istruzioni sono identiche:

if(x != null){ 
    //do the normal thing 
} 
else{ 
    //recover from the error 
} 

e

try{ 
    //do the normal thing 
} 
catch(NullPointerException ex){ 
    //recover 
} 

Tuttavia, utilizzando eccezioni è mai buona idea per una serie di motivi:

• i costi associati con lancio l'eccezione (ovvero la generazione di Throwable in Java)
• il flusso di controllo non è immediatamente evidente, ad esempio, se una NullPointerException può essere lanciata da più istruzioni nel blocco try, come si può dire che uno gettò nel blocco catch
• ecc, ecc

Answer 7

Il unica scopo di try/catch è il controllo di flusso. Ha lo scopo di permetterci di uscire da qualsiasi loop e persino di superare il chiamante e fino a una funzione di livello superiore.

Tuttavia, è progettato per condizioni eccezionali, come i riferimenti null in uso, il sovraccarico di divisione o l'errore di I/O di file. Si tratta di errori che impediscono al programma di continuare e deve essere gestito da. Generalmente, sono difficili da prevedere o sono molto rari.

Quando si verifica una condizione eccezionale, la cosa migliore da fare è modificare il flusso di controllo in modo che l'eccezione sia lanciata fino in fondo come deve essere al fine di trovare un blocco catch disposto a gestirlo. Qualsiasi metodo nel mezzo viene interrotto e svolto, anche se non ha codice per verificare i risultati.

Quando le persone si lamentano utilizzando try/catch per il controllo del flusso, quello che dovrebbe dire è che non è per il controllo del flusso in condizioni non eccezionali. Se tutto ciò che vuoi fare è uscire da un loop, usa break o return; non lanciare un'eccezione e poi prenderla. Questo non è ciò che le eccezioni sono per, né è ciò per cui sono buoni.

Answer 8

Quello che può mancare è più modi per non eseguire un po 'di codice ... Quindi, piuttosto che (in java)

if (cond1) { 
    some_code(); 
    if (cond2) { 
    some_more_code(); 
    if (condN) { 
     ad_infinitum 
    } 
    } 
} 

Questo può essere 'appiattito' di gettare un po' di spazzatura ...

try { 
    if (!cond1) throw new Throwable(); 
    some_code(); 
    if (!cond2) throw new Throwable(); 
    some_more_code(); 
    if (!condN) throw new Throwable(); 
    ad_infinitum(); 
} catch (Throwable ignore) { } 

Il problema è se una qualche eccezione reale è stata lanciata?Penso che ciò che il vostro collega dovrebbe scrivere se vuole appiattire il rientro è qualcosa di simile:

do { 
    if (!cond1) break; 
    some_code(); 
    if (!cond2) break; 
    some_more_code(); 
    if (!condN) break; 
    ad_infinitum(); 
} while (false); 

Dal do/while esegue sempre siamo in grado di utilizzare la pausa per approssimare un goto (a patto che tutto va per il stesso punto).