c++ - teoria - ¿Mejores prácticas para definir sus propias clases de excepción?

teoria general del proceso resumen

Question

Tengo algunos casos excepcionales especiales que quiero lanzar y atrapar, por lo que quiero definir mis propias clases de excepción.

¿Cuáles son las mejores prácticas para eso? ¿Debo heredar de std::exception o std::runtime_error ?

Answer 1

En mi opinión, no importa si heredas de std :: exception o no. Para mí, lo más importante acerca de la definición de excepciones es:

1. Tener los nombres de clase de excepción ser útil y claro.
2. Documentando claramente (escribiendo comentarios) cuando una función o un método de clase arrojarán una excepción. Este es el único punto de falla más grande en el manejo de excepciones en mi opinión.

Answer 2

Es bueno cuando se coloca una excepción en algún ámbito. Por ejemplo, la clase Manipulation puede declarar dentro de las clases de excepción Error.

y atraparlos como

catch ( const Manipulation::InputError& error )
catch ( const Manipulation::CalculationError& error )

En tales casos, pueden ser solo clases vacías sin ningún tipo de información de error adicional, a menos que el diseño permita que esas excepciones vuelen mucho más arriba, donde se capturan todas las excepciones estándar.

Answer 3

No hace una gran diferencia, ya que std::runtime_error también hereda de std::exception . Podría argumentar que el error de tiempo de ejecución transmite más información sobre la excepción, pero en la práctica, las personas a menudo derivan de la clase de excepción básica.

Answer 4

No soy desarrollador de C ++, pero una cosa que hicimos en nuestro código de C # fue crear una excepción de clase base para nuestro framework, y luego registrar la excepción lanzada en el constructor:

  public FrameworkException(string message, Exception innerException)
      : base(message, innerException)
  {
      log.Error(message, innerException);
  }

  ...

Cualquier excepción derivada solo tiene que invocar su constructor de base y obtenemos un registro de excepción consistente en todo. No es gran cosa, pero útil.

Answer 5

Sí, es una buena práctica inherit de std::runtime_error u otras clases de excepciones estándar como std::logic_error , std::invalid_argument etc., dependiendo de qué tipo de excepción sea.

Si todas las excepciones heredan algo de std::exception , es fácil detectar todos los errores comunes mediante un catch(const std::exception &e) {...} . Si tiene varias jerarquías independientes, esto se vuelve más complicado. Derivarse de las clases de excepciones especializadas hace que estas excepciones lleven más información, pero qué tan útil es realmente depende de cómo se maneje su excepción.