C++, questa dichiarazione goto è giustificata?

Question

Ho cambiato leggermente titolo perché ho pensato che fosse una domanda più appropriata.

Vuoi refactoring (sembra legittimo uso di goto)? Se, come dovresti refactoring il seguente codice per rimuovere go to statement?

if (data.device) { 
    try { 
     ... 
    } 
    catch(const std::exception&) { goto done; } 
    ... // more things which should not be caught 
done: ; 
} 

dichiarazione completa

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) { goto done; } 
       data.device += size; 
       host_index.extend(block_index); 
       block_index.data.clear(); 
      done: ; 
      } 
#endif 

ringraziamento

dopo aver visto la preferenza della maggior parte, ho deciso di andare con la bandiera, ma con il signor York commento.

Grazie a tutti

Answer 1

if (data.device) 
{ 
    bool status = true; 

    try 
    { 
     ... 
    } 
    catch(std::exception) 
    { 
     status = false; 
    } 

    if (status) 
    { 
    ... // more things which should not be caught 
    } 
} 

Answer 2

Non riesci a cogliere l'eccezione al di fuori del se?

Answer 3

if (data.device) { 
    bool ok = true; 
    try { 
     ... 
    } 
    catch(std::exception) { ok = false; } 

    if(ok) { 
     ... // more things which should not be caught 
    } 
} 

Answer 4

si può prendere l'eccezione e rigenerare una deroga specifica che può essere gestito al di fuori del blocco condizionale.

// obviously you would want to name this appropriately... 
struct specific_exception : std::exception { }; 

try { 
    if (data.device) { 
     try { 
      // ... 
     } 
     catch(const std::exception&) { 
      throw specific_exception(); 
     } 

     // ... more things which should not be caught ... 
    } 
} 
catch (const specific_exception&) { 
    // handle exception 
} 

Answer 5

Che ne dici di utilizzare solo un flag e aggiungere un'istruzione condizionale?

int caught = 0; 
if (data.device) { 
    try { 
     /* ... */ 
    } catch (std::exception e) { caught = 1; } 
    if (!caught) { 
     // more stuff here 
    } 
    // done: ... 
} 

Answer 6

Primo: goto non è il male di per sé. Refactoring per il puro gusto di non avere le lettere "goto" nel tuo codice non ha senso. Refactoring a qualcosa che ottiene la stessa cosa fatta più pulito di un goto va bene. Cambiare un cattivo design in uno che è migliore e non ha bisogno di un goto o di un sostituto per esso va bene, anche.

Detto questo, direi che il tuo codice sembra esattamente quello per cui è stato finalmente inventato. Troppo triste C++ non ha qualcosa di simile ... quindi forse la soluzione più semplice è lasciarla così.

Answer 7

Quando c'è un gruppo di codice che deve essere terminato in base a qualche condizione, il mio costrutto preferito è utilizzare un ciclo "do {} while (0)" e "interruzione" quando appropriato. Non so quale pausa; lo farò in una presa, però. Un "goto" potrebbe essere la soluzione migliore se "break" non funzionerà.

Answer 8

catch(std::exception) { return; } 

Questo dovrebbe fare il trucco. Naturalmente, presumo che lo done sia effettivamente alla fine di una funzione.

Se è necessario eseguire codice aggiuntivo quando si verifica un'eccezione, restituire uno stato o generare un'eccezione ad un livello più appropriato di astrazione (vedere la risposta di James).

sto immaginando qualcosa di simile:

doStuff(...) { 
    bool gpuSuccess = doGPUStuff(...); 
    if (!gpuSuccess) { 
     doCPUStuff(...); 
    } 
} 

Answer 9

Perché non spostare il codice aggiuntivo all'interno del blocco try ?:

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
        data.device += size; 
        host_index.extend(block_index); 
        block_index.data.clear(); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) { /* handle your exception */; } 
      } 
#endif 

Answer 10

Penso che una variante di questo potrebbe funzionare per voi.

// attempt to use GPU device 
if (data.device) 
{ 
    try 
    { 
     Integral::Gpu eri(S, R, Q, block.shell()); 
     eri(basis.centers(), quartets, data.device); 

     data.device += size; 
     host_index.extend(block_index); 
     block_index.data.clear(); 
    } 
    catch (const std::bad_alloc&) 
    { 
     // this failure was not because 
     // of the GPU, let it propagate 
     throw; 
    } 
    catch(...) 
    { 
     // handle any other exceptions by 
     // knowing it was the GPU and we 
     // can fall back onto the CPU. 
    } 
} 

// do CPU 

Se si potesse modificare la libreria GPU e dare tutte le eccezioni GPU alcuni di base come gpu_exception, il codice diventa molto più semplice:

// attempt to use GPU device 
if (data.device) 
{ 
    try 
    { 
     Integral::Gpu eri(S, R, Q, block.shell()); 
     eri(basis.centers(), quartets, data.device); 

     data.device += size; 
     host_index.extend(block_index); 
     block_index.data.clear(); 
    } 
    catch (const gpu_exception&) 
    { 
     // handle GPU exceptions by 
     // doing nothing and falling 
     // back onto the CPU. 
    } 

    // all other exceptions, not being 
    // GPU caused, may propagate normally 
} 

// do CPU 

Se inferi di questi lavori, penso che la cosa migliore è Steve's answer.

Answer 11

Uso leggermente diverso di una bandiera. Penso che sia più ordinato di quello di Amardeep.

Preferisco utilizzare un flag per indicare se propagare l'eccezione, di un flag per indicare se l'ultima cosa che ha funzionato, perché l'intero punto delle eccezioni è quello di evitare i controlli per se l'ultima cosa che ha funzionato - l'idea è di scrivere un codice tale che se siamo arrivati ​​così lontano, tutto ha funzionato e siamo pronti a continuare.

#ifdef HAVE_GPU 
    // attempt to use GPU device 
    if (data.device) { 
     bool dont_catch = false; 
     try { 
      ... 
      dont_catch = true; 
      ... // more things which should not be caught 
     } catch (...) { 
      if (dont_catch) throw; 
     } 
    } 
#endif 

Answer 12

mi sto perdendo qualcosa, o non sarebbe equivalente a spostare la parte tra il catch e done: etichetta all'interno del blocco try?

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
        data.device += size; 
        host_index.extend(block_index); 
        block_index.data.clear(); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) {} 
      } 
#endif 

Answer 13

Basta rompere fuori nella sua funzione/metodo (tra cui tutto quello che segue) e utilizzare la parola chiave return. Finché tutte le variabili hanno distruttori, sono allocate allo stack (o puntate intelligenti se inevitabili), quindi stai bene. Sono un grande fan delle funzioni/metodi di early-exit piuttosto che il controllo continuo delle flag.

ad esempio:

void myFunc() 
{ 
    String mystr("heya"); 
    try 
    { 
     couldThrow(mystr); 
    } 
    catch(MyException& ex) 
    { 
     return; // String mystr is freed upon returning 
    } 

    // Only execute here if no exceptions above 
    doStuff(); 
} 

In questo modo, è difficile sbagliare

Answer 14

La ragione Goto è di buon occhio oggi è che abbiamo queste cose di fantasia chiamati "funzioni", invece. Avvolgi il codice GPU nella sua funzione, che può tornare presto se non riesce.

Quindi chiamarlo dalla funzione originale.

Dal momento che probabilmente hanno bisogno di condividere alcune variabili (data, host_index e block_index, sembra), metterli in una classe, e rendere i due funzioni membri di esso.

void RunOnGpu(){ 
     // attempt to use GPU device 
     if (data.device) { 
      try { 
       Integral::Gpu eri(S, R, Q, block.shell()); 
       eri(basis.centers(), quartets, data.device); 
      } 
      // if GPU fails, propagate to cpu 
      catch(std::exception) { return; } 
      data.device += size; 
      host_index.extend(block_index); 
      block_index.data.clear();  
} 
void DoStuff() { 
#ifdef HAVE_GPU 
    RunOnGpu(); 
#endif 
}