Captura de clases base y derivadas como excepciones en C++ y Java

Una excepción es un error no deseado o un obstáculo que lanza un programa durante la compilación. Hay varios métodos para manejar una excepción que se denomina manejo excepcional . 

Analicemos qué es el manejo de excepciones y cómo capturamos las clases base y derivadas como una excepción en C++:

• Si tanto la clase base como la derivada se capturan como excepciones, el bloque catch de la clase derivada debe aparecer antes que la clase base. 
• Si ponemos la clase base primero, nunca se alcanzará el bloque catch de la clase derivada. Por ejemplo, el siguiente código de C++ imprime «Excepción base capturada « 
   

// C++ Program to demonstrate a
// Catching Base Exception
#include <iostream>
using namespace std;
 
class Base {
};
class Derived : public Base {
};
int main()
{
    Derived d;
    // Some other functionalities
    try {
        // Monitored code
        throw d;
    }
    catch (Base b) {
        cout << "Caught Base Exception";
    }
    catch (Derived d) {
        // This 'catch' block is NEVER executed
        cout << "Caught Derived Exception";
    }
    getchar();
    return 0;
}

La salida del código C++ anterior :

prog.cpp: In function ‘int main()’:
prog.cpp:20:5: warning: exception of type ‘Derived’ will be caught
    catch (Derived d) {
    ^
prog.cpp:17:5: warning:    by earlier handler for ‘Base’
    catch (Base b) {

En el código de C++ anterior, si cambiamos el orden de las declaraciones catch, ambas declaraciones catch se vuelven accesibles. 

El siguiente es el programa modificado e imprime «Excepción derivada capturada»

// C++ Program to demonstrate a catching of
// Derived exception and printing it successfully
#include <iostream>
using namespace std;
 
class Base {};
class Derived : public Base {};
int main()
{
    Derived d;
    // Some other functionalities
    try {
        // Monitored code
        throw d;
    }
    catch (Derived d) {
        cout << "Caught Derived Exception";
    }
    catch (Base b) {
        cout << "Caught Base Exception";
    }
    getchar(); // To read the next character
    return 0;
}

Producción:

Caught Derived Exception

En , el propio compilador no permite capturar una excepción de clase base antes de derivarla. En C++, el compilador puede dar una advertencia al respecto, pero compila el código. 

Por ejemplo, el siguiente código Java falla en la compilación con el mensaje de error «la excepción Derivada ya ha sido capturada» 
 

// Java Program to demonstrate
// the error filename Main.java
class Base extends Exception {
}
class Derived extends Base {
}
public class Main {
    public static void main(String args[])
    {
        try {
            throw new Derived();
        }
        catch (Base b) {
        }
        catch (Derived d) {
        }
    }
}

Error:

prog.java:11: error: exception Derived has already been caught
   catch(Derived d) {}