C++, ¿está justificada esta declaración goto?

Question

He cambiado un poco el título porque pensé que esta era la pregunta más adecuada.

¿Lo refactorizaría (parece uso legítimo de goto)? Si, ¿cómo podría refactorizar el siguiente código para eliminar ir a la declaración?

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

declaración 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 

agradecimiento

después de haber visto la preferencia de la mayoría, me decidí a ir con la bandera, pero con la observación del Sr. York.

Gracias a todos

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

¿No puede ver la excepción fuera de if?

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

se puede coger la excepción y volver a lanzar una excepción específica que puede ser manejado fuera del bloque condicional.

// 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

¿Qué tal si usamos algunos indicadores y agregamos un enunciado condicional?

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

Answer 6

Primero: goto is not evil per se. Refactorizar por el simple hecho de no tener las letras "goto" en tu código es una tontería. Refactándolo a algo que hace lo mismo más limpio que un goto está bien. Cambiar un diseño malo en uno que es mejor y no necesita un goto o un reemplazo para él también está bien.

Dicho esto, diría que su código se ve exactamente como para lo que finalmente se inventó. Demasiado triste C++ no tiene algo como esto ... así que tal vez la solución más fácil es dejarlo así.

Answer 7

Cuando hay un montón de código que necesita salir en función de alguna condición, mi construcción preferida es usar un bucle "do {} while (0)" y "romper" cuando sea apropiado. No sé qué descanso; lo hará en una captura, sin embargo. Un "goto" podría ser su mejor opción si "break" no funciona.

Answer 8

catch(std::exception) { return; } 

Que debe hacer el truco. Estoy, por supuesto, suponiendo que done está de hecho al final de una función.

Si necesita ejecutar código adicional cuando se produce la excepción, regrese un estado o ejecute una excepción que se encuentre en un nivel de abstracción más adecuado (consulte la respuesta de James).

estoy imaginando algo como:

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

Answer 9

Por qué se mueve el código adicional dentro del bloque 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

Creo que una variante de esto podría funcionar para usted.

// 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 

Si usted podría editar la biblioteca GPU y dar todas las excepciones GPU alguna base como gpu_exception, el código se vuelve mucho más sencillo:

// 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 

Si abisal de estos trabajos, creo que la mejor alternativa es Steve's answer.

Answer 11

Uso un poco diferente de una bandera. Creo que es más limpio que el de Amardeep.

Prefiero usar una bandera para indicar si se debe propagar la excepción, que una bandera para indicar si la última cosa funcionó, porque el punto entero de excepciones es para evitar verificaciones de si lo último funcionó - la idea es escribir un código tal que, si llegamos tan lejos, todo funcionó y estamos en condiciones de continuar.

#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

Me estoy perdiendo algo, o ¿no sería equivalente a mover la parte entre el catch y done: etiqueta dentro del bloque de 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

Sólo romper hacia fuera en su propia función/método (incluyendo todo, después de él) y el uso de la palabra clave return. Siempre que todas sus variables tengan destructores, sean asignadas en pila (o puntadas inteligentes si es inevitable), entonces está bien. Soy un gran admirador de las funciones/métodos de salida temprana en lugar de la verificación continua de banderas.

por ejemplo:

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(); 
} 

De esta manera, es difícil equivocarse

Answer 14

La razón Goto está mal visto en la actualidad es que tenemos estas cosas de lujo denominan "funciones" en su lugar. Envuelva el código GPU en su propia función, que puede regresar temprano si falla.

Luego llame a eso desde su función original.

ya que probablemente tendrán que compartir algunas variables (data, host_index y block_index, parece), ponerlos en una clase, y crea los dos miembros de las funciones de la misma.

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 
}