PDF de programación - Tema 5 - Gestión de errores

TEMA 5

GESTIÓN DE ERRORES
Cristina Cachero, Pedro J. Ponce de León

1 Sesión (1.5 horas)

Versión 0.5

Depto. Lenguajes y Sistemas Informáticos

Gestión Errores
Objetivos
 Saber utilizar try, throw y catch para observar, indicar y

manejar excepciones, respectivamente.

 Comprender la jerarquía de excepciones estándar.
 Ser capaz de crear excepciones personalizadas
 Ser capaz de procesar las excepciones no atrapadas y las

inesperadas.

Curso 2007-2008

2

Gestión de Errores
Motivación

 Realizar un programa que solicite dos números y visualice la división

de ambos.

int main()
{
float dividendo, divisor, resultado;
cout << "PROGRAMA DIVISOR" << endl;
cout << "Introduce Dividendo : " ;
cin >> dividendo;
cout << "Introduce Divisor : " ;
cin >> divisor;
resultado = dividendo / divisor;
cout << dividendo << "/" << divisor << "=" << resultado;
return (0);
}

 ¿Qué ocurre si el usuario introduce un divisor=0?

Curso 2007-2008

3

Gestión de Errores
Motivación
 Esto obliga a definir un esquema de programación similar a :

 Llevar a cabo tarea 1
 Si se produce error

 Llevar a cabo procesamiento de errores

 Llevar a cabo tarea 2
 Si se produce error

 Llevar a cabo procesamiento de errores





¿Qué problemas podéis detectar en este esquema?
 Entremezcla la lógica del programa con la del tratamiento de errores (disminuye

legibilidad)

 Puede degradar el rendimiento del sistema

¿Qué podemos hacer en lugar de crear código spaguetti?:
 Abortar el programa

 ¿Y si el programa es crítico?

 Usar indicadores de error (Ej Una función devuelve un código de error.)

 ¿Se comprueban siempre?

 USAR EXCEPCIONES

Curso 2007-2008

4

Gestión de Errores
Excepciones: Concepto
 Una excepción es un evento que ocurre durante la ejecución del

programa que interrumpe el flujo normal de las sentencias

 Muchas clases de errores pueden utilizar excepciones -- desde serios

problemas de hardware, como la avería de un disco duro, a los simples
errores de programación
 División por cero
 Acceso a un índice incorrecto de un tipo de las STL
 Fallo en la reserva de memoria del new
 ...

 Las excepciones pueden ser ignoradas si conviene.

Curso 2007-2008

5

Gestión de Errores
Excepciones: Sintaxis

C++
try
{
// Codigo de ejecución normal
throw Tipo1();
}
catch (Tipo1 &ex)
{
// Gestión de excep tipo 1
}
catch (Tipo2 &ex)
{
// Gestión de excep tipo 2
}
catch (...)
{
/* Gestión de cualquier excep no
capturada mediante los catch
anteriores*/

}
//Continuación del código

JAVA
try
{
// Codigo de ejecución normal
throw new Tipo1();
}
catch(Tipo1 ex)
{
// Gestión de excep tipo 1
}
catch(Tipo2 ex)
{
// Gestión de excep tipo 2
}
finally{
// se ejecuta siempre
}

Curso 2007-2008

6

Gestión de Errores
Excepciones: Sintaxis



En C++ y en Java:





El bloque try contiene el código que forma parte del funcionamiento
normal del programa
El bloque catch contiene el código que gestiona los diversos errores que
se puedan producir



Sólo en JAVA:



El bloque finally de Java proporciona un mecanismo que permite a sus
métodos limpiarse a sí mismos sin importar lo que sucede dentro del
bloque try. Se utiliza el bloque finally para cerrar ficheros o liberar otros
recursos del sistema. El bloque finally se puede ejecutar (1) tras finalizar
el bloque try o (2) después de las cláusulas catch.

Curso 2007-2008

7

Gestión de Errores
Excepciones: Sintaxis







Funcionamiento:
 Ejecutar instrucciones try

 Si hay error, interrumpir el bloque try e ir a bloque catch correspondiente (*)

 Continuar la ejecución después de los bloques catch

La excepción es capturada por el bloque-catch cuyo argumento coincida con
el tipo de objeto lanzado por la sentencia throw. La búsqueda de
coincidencia se realiza sucesivamente sobre los bloques catch en el orden
en que aparecen en el código hasta que aparece la primera concordancia.



Implica que el orden de colocación de los bloques catch es determinante.
Por ejemplo: si se incluye un manejador universal, éste debería ser el último.

En caso de no existir un manejador adecuado a una excepción determinada,
se desencadena un protocolo que, por defecto, produce sin más la
finalización del programa

Curso 2007-2008

8

Gestión de Errores
Excepciones: lanzamiento
 La cláusula throw lanza la excepción como un objeto
 Ejemplo

#include <iostream>
#include <exception>
using namespace std;

class miExcepcion {
string queHaPasado() const
{return “Ocurrió mi excepción”; }
};

int main(){
try{ throw miExcepcion(); }
catch(miExcepcion &e){ cout<<e.queHaPasado()<<endl; }
return (0);
}

¿Qué ocurriría si catch
recibiese el parámetro

por valor?

Curso 2007-2008

9

Gestión de Errores
Excepciones: especificación de soporte
 En C++ existe una opción denominada especificación de excepción
que permite señalar que tipo de excepciones puede lanzar una función
directa o indirectamente (en funciones invocadas desde ella). Este
especificador se utiliza en forma de sufijo en la declaración de la función
y tiene la siguiente sintaxis:

throw (<lista-de-tipos>) // lista-de-tipos es opcional

 La ausencia de especificador indica que la función puede lanzar

cualquier excepción.

Curso 2007-2008

11

Gestión de Errores
Excepciones estándares en C++
 Todas las excepciones lanzadas por componentes de la Librería Estándar de
C++ son excepciones derivada de la superclase exception, definida en la
cabecera <exception>, que tiene la siguiente interfaz:
class exception {

public:
exception () throw();
exception (const exception&) throw();
exception& operator= (const exception&) throw();
virtual ~exception () throw();
virtual const char* what () const throw();
};

 Esta clase tiene cinco métodos públicos, ninguno de los cuales puede lanzar

una excepción (cláusula throw()).

 Además, la clase exception proporciona una función miembro virtual what(), que
devuelve un const char * con un mensaje verbal (dependiente del compilador que
estéis utilizando) que refleja el tipo concreto de excepción.

 Este mensaje puede ser sobrescrito en clases derivadas para contener una descripción

personalizada de la excepción.

Curso 2007-2008

12

Gestión de Errores
Excepciones estándares en C++
 Tipos de excepciones (I):

 logic_error:

 domain_error



invalid_argument
length_error
 out_of_range



 runtime_error
range_error



 overflow_error
 underflow_error

class logic_error : public exception {
public:
explicit logic_error (const string& what_arg);
};
class domain_error : public logic_error {
public:
explicit domain_error (const string& what_arg);
};

class runtime_error : public exception {
public:
explicit runtime_error (const string& what_arg);
};
class range_error : public runtime_error {
public:
explicit range_error (const string& what_arg);
};

Curso 2007-2008

13

Gestión de Errores
Excepciones estándares en C++
 Tipos de excepciones (II):

 Otros tipos (que también heredan de exception):

 bad_alloc: lanzada por el operador new si hay un error de reserva de memoria
 bad_cast: lanzada por el operador dynamic_cast si no puede manejar un tipo

referenciado

 bad_exception: excepción genérica lanzada cuando un tipo de excepción no

está permitida en una función determinada

 El tipo de excepciones permitidas se especifica con la cláusula throw().

 bad_typeid: lanzado por el operador typeid a una expresión nula

ios_base::failure: lanzado por las funciones en la librería iostream



Curso 2007-2008

14

Gestión de Errores
Excepciones estándares en C++
 Ubicación de las excepciones:

 std::exception está definida en la cabecera <exception>.
 std::bad_alloc está definida en la cabecera <new>.
 std::bad_cast está definida en la cabecera <typeinfo>.
 El resto de excepciones están definidas en la cabecera <stdexcept>.

 Todas las excepciones estándares pueden ser lanzadas implícitamente

por el sistema o de manera explícita por el programador
 P. ej.

throw out_of_range(“límite por debajo array”);

Curso 2007-2008

15

Gestión de Errores
Excepciones estándares en C++: reserva memoria

int main()
{

double *ptr[50];
for (int i= 0 ; i < 50; i++) {
ptr[i] = new double[50000000];

cout << “Reservo memoria elemento " << i << endl;

return (0);

}

 ¿Qué ocurre si me quedo sin memoria disponible?

 El programa aborta.

Curso 2007-2008

16

Gestión de Errores
Excepciones estándares en C++: reserva memoria
#include <iostream>
#include <exception>
using namespace std;

int main()
{

double *ptr[50];
try {

for (int i= 0 ; i < 50; i++) {

ptr[i] = new double[50000000];

cout << "Reservando memoria para elemento " << i << endl;

}
}
catch (bad_alloc &ex){
cout << "Ocurrio un error de tipo " << ex.what() << endl;
}

cout<<“Termino programa normalmente”<<endl;

return (0);

}

Curso 2007-2008

17

Gestión de Errores
Excepciones predefinidas en C++: reserva memoria

Reservando memoria para elemento 0
Reservando memoria para elemento 1
Reservando memoria para elemento 2
Reservando memoria para elemento 3
Ocurrio un error de tipo bad allocation
Termino programa normalmente
Press any key to continue

Curso 2007-2008

18

Gestión de Errores
Excepciones estándares en C++: error fichero
int main()
{
fstream fic1;

fic1.open ("lucas.txt",ios::in);
fic1.close();

cout<<"Termino programa normalmente"<<endl;
return (0);
}

 Si el fichero no existe no ocurre nada. Pero podemos utilizar excepciones con

ficheros.

Curso 2007-2008

19

Gestión de Errores
Excepciones estándares en C++: error fichero
#include <fstream>
#include <iostream>
#include <exception>
using namespace std;
int main()
{
fstream fic1;
fic1.exceptions(ios::failbit); //los fich por defecto no lanzan excepciones
try{
fic1.open ("lucas.txt",ios::in); //LANZA ios_base::failure
}
catch (ios_base::failure &ex){
cout<<"Error al abrir el fichero"<<endl;
}