Ejemplo 1: programa para crear una clase de excepción personalizada en C++
Este sencillo ejemplo se implementa para demostrar el manejo y la detección de excepciones personalizados en C++.
#incluir#incluir
usando espacio de nombres enfermedad de transmisión sexual ;
clase Excepción de demostración : público excepción
{
virtual constante carbonizarse * qué ( ) constante tirar ( )
{
devolver 'Se detectó una excepción personalizada' ;
}
} ;
En t principal ( )
{
DemoException dEx ;
intentar
{
tirar dex ;
}
atrapar ( excepción & excepto )
{
corte << excepto. qué ( ) << fin ;
}
devolver 0 ;
}
Definimos el archivo de encabezado en el código, incluidos 'iostream' y 'excepción'. El 'iostream' se llama específicamente para el flujo de entrada y salida, mientras que la biblioteca 'exception' se llama para manejar la excepción. Después de esto, creamos la clase 'DemoException' que se deriva de la clase 'excepción' de C++. Aquí, configuramos la función virtual what() que se utiliza para proporcionar el const char* que muestra los resultados de un mensaje de error vinculado a la excepción.
Luego, invocamos una función main() donde creamos el objeto “dEx” de la clase “DemoException”. Después de eso, tenemos una definición de bloque 'probar' que genera la excepción si se encuentra. Aquí arrojamos el objeto 'dEx'.
A continuación, configuramos el bloque 'catch' para detectar la excepción y manejarla. Pasamos la referencia de la clase excepción como parámetro para capturar la excepción que se deriva de ella. Dentro del bloque 'catch', llamamos a la función what() en 'excepto' para obtener el mensaje de excepción en la consola.
Después de ejecutar el programa dado, el mensaje de excepción personalizado se captura y se arroja a la consola:
Ejemplo 2: programa para crear una excepción personalizada utilizando dos clases
El programa enfatiza el manejo de múltiples excepciones que se pueden manejar de forma independiente definiendo múltiples clases.
#incluir
usando espacio de nombres enfermedad de transmisión sexual ;
clase evaluación1 { } ;
clase evaluación2 { } ;
En t principal ( ) {
intentar {
tirar evaluación1 ( ) ;
}
atrapar ( evaluación1 e ) {
corte << '¡Excepción de evaluación1 detectada!' << fin ;
}
intentar {
tirar evaluación2 ( ) ;
}
atrapar ( evaluación2 e ) {
corte << '¡Excepción de la evaluación 2 detectada!' << fin ;
}
devolver 0 ;
}
En el código dado, tenemos la definición de dos clases, 'Evaluación1' y 'Evaluación2', que ahora están vacías. Después de eso, llevamos a cabo la función main() del programa. Aquí, configuramos el bloque try{} donde se usa la palabra clave 'throw' para lanzar la instancia de la clase 'Evaluación1()'. Esto representa que se lanza la excepción 'Evaluación1' si surge alguna excepción en el programa dentro de este bloque 'intentar'. Después de eso, tenemos un bloque catch{} donde se captura la excepción y muestra el mensaje de la excepción.
De manera similar, tenemos una definición de otro bloque try{} para la clase 'Evaluación2'. Dentro de ese bloque try{}, lanzamos la instancia de la clase 'Evaluación2'. Esto genera la excepción de 'Evaluación2' si ocurre un error aquí. Luego, llamamos al bloque catch{} para mostrar el mensaje de excepción usando el comando 'cout' si la excepción se detecta dentro de este bloque.
Las dos excepciones de los diferentes bloques 'try-catch' se lanzan en la consola y son manejadas por las dos clases diferentes.
Ejemplo 3: Programa para crear una excepción personalizada con Constructor
El programa utiliza el constructor para manejar la excepción. Aunque no podemos obtener los valores del constructor, podemos lograrlo usando el bloque 'try-catch'.
#incluirusando espacio de nombres enfermedad de transmisión sexual ;
clase Prueba {
En t vale ;
público :
Prueba ( En t norte )
{
intentar {
si ( norte == 0 )
vale = norte ;
mostrar ( ) ;
}
atrapar ( constante carbonizarse * Exp ) {
corte << 'Excepción encontrada \norte ' ;
corte << Exp << fin ;
}
}
vacío mostrar ( )
{
corte << 'Valor = ' << vale << fin ;
}
} ;
En t principal ( )
{
Prueba ( 0 ) ;
corte << 'Creando instancia nuevamente \norte ' ;
Prueba ( 1 ) ;
}
En el código dado, establecemos la clase 'Prueba' donde la variable se declara como 'val' de tipo entero. Luego, tenemos una definición de la función constructora 'Test()' que se pasa con la variable 'n'. Luego configuramos el bloque 'try-catch' dentro de la función constructora 'Test()'. El bloque try se llama con la declaración if(). Si el valor de 'n' es igual a cero, el bloque 'catch' detectará la excepción y el mensaje de excepción se generará en el mensaje. El valor de 'n' se almacena en la variable 'val' a medida que lo inicializamos.
Después de eso, llamamos a la función display() para mostrar el valor almacenado en la variable 'val'. A continuación, tenemos la definición del bloque 'catch' donde se maneja la excepción lanzada por el bloque 'try'. Finalmente, invocamos la función main(). Dentro del cual llamamos al constructor “Test()”. El constructor se activa cuando se crea el objeto de la clase 'Test()' y se especifica con el valor '0' en el que se lanza la excepción.
Después de eso, volvemos a llamar a la clase “Test()” para crear una instancia que se pasa con el valor de 1. Aquí, el constructor no lanzará ninguna excepción ya que el valor no es igual a 0. La función display() ejecute e imprima el valor de 'val'.
La excepción personalizada se genera en la consola llamando al constructor. Además, cuando se cumple la condición, el constructor se ejecuta sin excepción.
Ejemplo 4: programa para crear una excepción personalizada definida por el usuario
El programa aquí maneja y detecta la excepción definida por el usuario cuando se le solicita en el mensaje.
#incluir#incluir
usando espacio de nombres enfermedad de transmisión sexual ;
clase Mi demostración : público excepción {
público :
constante carbonizarse * qué ( ) constante tirar ( )
{
devolver '¡Excepción! ¡Intenté dividir por cero! \norte ' ;
}
} ;
En t principal ( )
{
intentar
{
En t n1, n2 ;
corte << 'Ingrese los dos números enteros: \norte ' ;
comiendo >> n1 >> n2 ;
si ( n2 == 0 )
{
Mi demostración n3 ;
tirar n3 ;
}
demás
{
corte << 'n1/n2 = ' << n1 / n2 << fin ;
}
}
atrapar ( excepción & Excª )
{
corte << Excª. qué ( ) ;
}
}
En el código dado, primero definimos la clase 'MyDemo()', que es la clase dependiente de la excepción. Después de eso, configuramos la función pública what() con la palabra clave 'virtual'. La función what() se llama para obtener la causa de la excepción en el programa cuando la función throw() arroja la excepción. Luego, tenemos una función main() donde se definen los bloques try-catch{} para detectar y manejar la excepción. Dentro del bloque try{}, declaramos dos variables, 'n1' y 'n2', cuyos valores se toman del usuario mediante el comando 'cin'. Cuando se reciben los valores de cada variable 'n1' y 'n2', la condición 'si' comprobará si la variable 'n2' es igual a 0 o no. Si es así, se lanza una excepción o se devuelven los resultados de la división. Por último, tenemos un bloque catch{} que toma la referencia de la clase 'excepción' como parámetro heredado de ella.
El resultado muestra cuando no se cumple la condición y el programa se ejecuta sin excepción:
Además, definimos el valor de '0' para la variable 'n2' para representar cómo se lanza y captura la excepción en el programa.
Conclusión
En conclusión, demostramos el importante concepto de C++, que es una excepción. Una excepción dificulta la ejecución regular del programa. Para ello, utilizamos las palabras clave 'throw', 'try' y 'catch' para manejar la excepción que ocurre en el programa. Usamos estas palabras clave en los ejemplos anteriores para manejar la excepción de manera diferente.