Comparación del manejo de excepciones en C++ y Java

Ambos lenguajes utilizan para probar, capturar y lanzar palabras clave para el manejo de excepciones, y su significado también es el mismo en ambos lenguajes. 

Las siguientes son las diferencias entre el manejo de excepciones de Java y C++:

Los puntos anteriores se han discutido en detalle a continuación:

1) En C++, todos los tipos (incluidos los primitivos y los punteros) se pueden lanzar como excepciones. Pero en Java, solo los objetos arrojables (los objetos arrojables son instancias de cualquier subclase de la clase arrojable) pueden arrojarse como excepciones. Por ejemplo, el siguiente tipo de código funciona en C++, pero un código similar no funciona en Java.

// CPP Program to demonstrate all types (including primitive
// and pointer) can be thrown as exception.
#include <iostream>
using namespace std;
int main()
{
    int x = -1;
  
    // some other stuff
    try {
        // some other stuff
        if (x < 0) {
            throw x;
        }
    }
    catch (int x) {
        cout << "Exception occurred: thrown value is " << x
             << endl;
    }
    getchar();
    return 0;
}

Exception occurred: thrown value is -1

2) En C++, hay una captura especial llamada «capturar todo» que puede capturar todo tipo de excepciones.  

// CPP Program to demonstrate catch all
#include <iostream>
using namespace std;
int main()
{
    int x = -1;
    char* ptr;
  
    ptr = new char[256];
  
    try {
  
        if (x < 0) {
            throw x;
        }
        if (ptr == NULL) {
            throw " ptr is NULL ";
        }
    }
    catch (...) // catch all
    {
        cout << "Exception occurred: exiting " << endl;
        exit(0);
    }
  
    getchar();
    return 0;
}

Exception occurred: exiting 

En Java, a todos los efectos prácticos, podemos capturar objetos de excepción para capturar todo tipo de excepciones. Porque normalmente no capturamos Throwable (s) que no sean Exception (s) (que son errores) 

catch(Exception e){
 …….
}

3) En Java, hay un bloque llamado finalmenteque siempre se ejecuta después del bloque try-catch. Este bloque se puede utilizar para realizar trabajos de limpieza. No existe tal bloque en C++. 

// Java Program to demonstrate creating an exception type
class Test extends Exception {
}
  
class Main {
    public static void main(String args[])
    {
  
        try {
            throw new Test();
        }
        catch (Test t) {
            System.out.println("Got the Test Exception");
        }
        finally {
            System.out.println("Inside finally block ");
        }
    }
}

Got the Test Exception
Inside finally block 

4) En C++, todas las excepciones están desmarcadas. En Java, hay dos tipos de excepciones: marcadas y no marcadas. Consulte esto para obtener más detalles sobre las excepciones marcadas y no marcadas.

5) En Java, se utiliza una nueva palabra clave throws para enumerar las excepciones que puede generar una función. En C++, no hay una palabra clave throws , la misma palabra clave throw también se usa para este propósito.

6) En C++, si la excepción no se detecta, el subsistema de manejo de excepciones llama a la función inesperado(), que finaliza el programa o una aplicación de manera anormal. Si surge alguna excepción en nuestro programa C++, encontrar esa excepción en particular requiere mucho tiempo porque en C++ inesperado() no nos dijo qué tipo y en qué línea ocurrió la excepción. Para obtener más detalles sobre inesperado(), consulte esto.

Pero en Java, si la excepción generada por el sistema no se detecta, el sistema de tiempo de ejecución de Java (JVM) entrega el objeto de excepción al controlador de excepciones predeterminado, que básicamente imprime el nombre, la descripción y en qué línea se produjo la excepción. Entonces, en Java encontrar y manejar la excepción es más fácil que en el lenguaje C++. 

Para obtener más detalles sobre el controlador de excepciones predeterminado, consulte esto.