¿Cómo evitar escribir código repetido en bloques catch?

Question

estoy usando QT 4.8 (C++) para el proyecto de aplicación de escritorio, y escribir el manejo de excepciones es el siguiente:

void callerMethod() 
{ 
    try 
    { 
    method1(); 
    } 
    catch(Exception1& e) 
    { 
    // display critcal error message 
    // abort application 
    } 
    catch(std::Exception& e) 
    { 
    // print exception error message 
    } 
    catch(...) 
    { 
    // print unknown exception message 
    } 
} 

void method1() 
{ 
    try 
    { 
    // some initializations 
    // some operations (here exceptions can occur) 
    // clean-up code (for successful operation i.e no exception occurred) 
    } 
    catch(Exception1& e) 
    { 
    // clean-up code 
    throw e; 
    } 
    catch(Exception2& e) 
    { 
    // clean-up code 
    throw e; 
    } 
    catch(Exception3& e) 
    { 
    // clean-up code 
    throw e; 
    } 
    catch(...) 
    { 
    // clean-up code 
    throw; 
    } 
} 

Así que mi pregunta qué tengo que escribir el código de limpieza en cada bloque catch ? ¿Hay alguna manera de que pueda evitar escribir código repetido?

NOTA :: [En metodo1()] Quiero volver a arrojar excepciones que se produjeron a mi caller.So No puedo atraparlos en un solo bloque catch, ya continuación, escriba la información se perderá .

Answer 1

Método1 puede ser mucho más simplificado por dos conceptos:

1. RAII. Ponga cualquier código de limpieza en destructores, y el código de limpieza estará centralizado.
2. Utilice el throw no calificado, y no tendrá que saber sobre el tipo de excepción lanzada.

Así, method1() debe verse como:

void method1() 
{ 
    // some initializations of RAII objects 
    // some operations (here exceptions can occur) 
} 

La primera cláusula en catchcallerMethod se puede quitar si usted deriva Exception1 de std::exception, ya que el método what() es virtual.

Answer 2

Si todo el código que su limpieza es totalmente idéntica, se puede hacer todo en su captura (...) bloques:

try { 
    // code 
} catch (...) { 
    // cleanup 
    throw; 
} 

Si el código varía ligeramente, siempre puede llamar a una función de limpieza:

try { 
    // code 
} catch (exc1 ex) { 
    cleanup(args); 
    // exc1 specific 
    throw; 
} catch (exc2 ex) { 
    cleanup(args); 
    // exc2 specific 
    throw; 
} catch (...) { 
    cleanup(args); 
    throw; 
} 

Answer 3

Debe tirar las excepciones lo más bajo posible y atraparlas lo más alto posible en la cadena de llamadas. Esto conduce automáticamente a una menor duplicación de código y centraliza el manejo de errores. Estás arrojando/atrapando a todos en un solo lugar, lo que parece un poco ... forzado.

hago a menudo este tipo de cosas (especialmente para las excepciones de fin de programa:.

int main() 
try 
{ 
    function_calls_that_may_throw(); 
    // ... 
} 
catch(my_exception& e) 
{ 
    e.do_exception_stuff(); 
} 
catch(std::exception& e) 
{ 
    std::cout << e.what(); 
} 
catch(...) 
{ 
    std::cout << "Something bad happened.\n"; 
} 

Esto sólo es posible por lanzar excepciones que no piensa en el manejo de mejor o volver a intentar la operación fallida o algo

El pro de este enfoque es que todo/la mayoría de los códigos de manejo de errores están en el nivel superior de su programa, y ​​todas las funciones en la cadena de llamadas no tienen que preocuparse ni un poquito sobre esto, todo lo que hacen es lanzar una excepción cuando lo deseen.