Excepciones a C++: ¿Por qué usar o extender std :: exception?

Question

De acuerdo con this site es perfectamente útil para lanzar una cuerda o un número entero. Encuentro esto bastante limpio y fácil de entender. ¿Cuáles son las desventajas de throw "description of what happened" en lugar de throw std::runtime_error("description of what happened")?

Answer 1

Ese sitio es estúpido, y enseña mal diseño.

Si se lanza int o char*, entonces tendrá que atraparlo usando int o char* solamente. Puede calificarlo con const.

Si arroja std::runtime_error, puede capturarlo usando std::runtime_error const &, o su clase base std::exception const &.

¿Qué tiene de bueno esto?

El bueno de esto es que si se arroja una excepción el uso de una clase que se deriva en última instancia std::exception, entonces se puede escribir sólo UN catch bloque que acepta la excepción, ya que std::exception const&, independientemente de which derived class se utiliza para lanzar una excepción.

Aquí está un ejemplo:

void f(A & a) 
{ 
    if (!check_arg(a)) 
    { 
      throw std::invalid_argument("invalid argument"); 
    } 
    else if (!check_size(a)) 
    { 
      throw std::length_error("invalid length");    
    } 

    //code 
    if(someCondition) 
    { 
      //assume your_own_defined_exception's ultimate base is std::exception 
      throw your_own_defined_exception("condition unsatisfied");       
    } 
    //... 

} 

Ahora la parte interesante:

try 
{ 
     f(a); //it can throw exception of at least 3 types! 
} 
catch(std::exception const &e) //all types can be caught by just one catch! 
{ 
    //handle this case 
} 

Lo bueno es que usted no es requiere escribir trescatch bloques sólo porque f() podría lanzar tres diferentes tipos de excepción. Usted puede escribir más de un catch para manejarlos de manera diferente si eso lo beneficia de alguna manera. Pero el punto a tener en cuenta aquí es: no ¡un requisito!

En resumen, puede aprovechar la jerarquía de clases.

Answer 2

Principalmente porque cuando trabajas con otras personas tienes que acordar qué atrapar. Si trato de atrapar un const std::exception& y arrojas const char*, entonces no voy a atrapar tus cosas y podrían pasar cosas malas.

Realmente no importa qué tipo se tira y atrapa, siempre y cuando todos se apeguen a él. Supongo que std::exception se elige sobre const char* porque le permite poner más que solo una cadena en el objeto de excepción. Es simplemente más flexible.

Answer 3

Si hace que una regla en su código arroje excepciones solo derivadas de std :: exception, es más fácil capturarlas. En otras palabras, sólo puede tener una sola cláusula catch en std :: excepción:

catch (std::exception& e) 
{ 
    log_message(e); 
    throw; 
} 

Pero si usted no sigue esta regla, entonces al final tener que escribir cláusulas de captura cuando no tiene que hacerlo.

Answer 4

Un punto adicional provocada por otras respuestas es esto -

Si se lanza un entero o una cadena y que se desea capturar una error específico no se puede. Debe capturar todas las excepciones "int" y luego comparar las que desea capturar, y luego volver a lanzar las que no esté preparado para tratar. Si heredas de la excepción, puedes atrapar la excepción específica que deseas manejar y aún así tener la ventaja de poder capturar std :: exception si quieres manejarlas todas.