Jerarquía de excepciones C II

Vista previa del material en texto

Jerarquía de excepciones C++
La jerarquía de excepciones en C++ es una característica que nos permite organizar y
clasificar las excepciones en una estructura jerárquica. Esta jerarquía nos ayuda a capturar
y manejar excepciones de manera más eficiente y estructurada, permitiéndonos tomar
medidas específicas según el tipo de excepción que se haya lanzado.
En C++, las excepciones se organizan en una jerarquía basada en la herencia de clases.
Esto significa que podemos definir clases de excepción que heredan de otras clases de
excepción, creando una estructura jerárquica de excepciones. La clase base de la jerarquía
de excepciones en C++ es la clase "std::exception", que proporciona una interfaz común
para todas las excepciones.
Para crear una nueva clase de excepción, simplemente debemos heredar de la clase
"std::exception" o de una de sus clases derivadas. Por ejemplo, podemos crear una clase
de excepción personalizada llamada "MiExcepcion" de la siguiente manera:
class MiExcepcion : public std::exception {
public:
 const char* what() const noexcept override {
 return "Ocurrió una excepción personalizada";
 }
};
En este caso, hemos creado una clase de excepción llamada "MiExcepcion" que hereda
de la clase "std::exception". Hemos sobrescrito el método "what()" para proporcionar un
mensaje de error personalizado.
Al organizar las excepciones en una jerarquía, podemos capturar y manejar excepciones
de manera más específica. Podemos utilizar bloques "catch" para capturar excepciones de
un tipo específico y manejarlas de manera adecuada. Si no se encuentra un bloque "catch"
adecuado para una excepción específica, la excepción se propagará hacia bloques "catch"
superiores hasta que se encuentre un bloque "catch" adecuado o hasta que el programa
termine.
Por ejemplo, supongamos que tenemos una jerarquía de excepciones que incluye una
excepción base llamada "ExcepcionBase" y dos excepciones derivadas llamadas
"ExcepcionDerivada1" y "ExcepcionDerivada2". Podemos capturar y manejar estas
excepciones de la siguiente manera:
try {
 // Código que puede lanzar excepciones
} catch (const ExcepcionDerivada1& e) {
 // Código para manejar la excepción de tipo ExcepcionDerivada1
} catch (const ExcepcionDerivada2& e) {
 // Código para manejar la excepción de tipo ExcepcionDerivada2
} catch (const ExcepcionBase& e) {
 // Código para manejar la excepción de tipo ExcepcionBase
} catch (...) {
 // Código para manejar cualquier excepción no capturada anteriormente
}
En este caso, hemos capturado y manejado excepciones específicas de los tipos
"ExcepcionDerivada1" y "ExcepcionDerivada2". Si se lanza una excepción de alguno de
estos tipos, se capturará en el bloque "catch" correspondiente. Si se lanza una excepción
de tipo "ExcepcionBase", se capturará en el bloque "catch" correspondiente. Si se lanza
cualquier otra excepción no capturada anteriormente, se capturará en el bloque "catch"
genérico.
La jerarquía de excepciones en C++ nos permite capturar y manejar excepciones de
manera más específica y estructurada. Al organizar las excepciones en una jerarquía,
podemos tomar medidas adecuadas según el tipo de excepción que se haya lanzado. Esto
nos ayuda a mejorar la robustez y la confiabilidad de nuestros programas, permitiéndonos
manejar errores y situaciones excepcionales de manera más controlada.
Es importante tener en cuenta que el uso adecuado de la jerarquía de excepciones implica
lanzar excepciones específicas para cada tipo de error y capturar excepciones de manera
adecuada y estructurada. Además, es recomendable utilizar excepciones específicas en
lugar de capturar excepciones genéricas, ya que esto nos permite tomar medidas más
precisas según el tipo de error.
En resumen, la jerarquía de excepciones en C++ nos permite organizar y clasificar las
excepciones en una estructura jerárquica. Al utilizar bloques "catch" específicos,
podemos capturar y manejar excepciones de manera más estructurada y tomar medidas
adecuadas según el tipo de excepción que se haya lanzado. Esto nos ayuda a mejorar la
robustez y la confiabilidad de nuestros programas, permitiéndonos manejar errores y
situaciones excepcionales de manera más controlada.