Informática IIProf. Dr. Gustavo PatiñoMJ 16- 1804-03-2014

Objetivos: Saber manejar situaciones inesperadas

dentro de un programa Comprender como controlar las

situaciones inesperadas. Saber lanzar excepciones. Saber manejar excepciones. Conocer los distintos tipos de

excepciones.

Contenidos: Definición de excepción. Tipos de excepciones. Manejo de excepciones. Try – Throw – Catch. Clase Exception. Ejemplos.

Si uno de esos errores se produce y no implementamos el manejo de excepciones: El programa terminará abruptamente. Es muy probable que si hay archivos

abiertos no se guarde el contenido de los buffers, ni se cierren.

Además ciertos objetos no serán destruidos, y se producirán “fugas de memoria”.

En programas pequeños se puede prevenir las situaciones en que se pueden producir excepciones, y “evitarlas”.

Sólo nos queda evitar peticiones de memoria que puedan fallar, pero eso no es previsible.

Sin embargo, C++ proporciona un mecanismo lo suficiente potente para detectar errores de ejecución: Las excepciones. Para ello se dispone de tres palabras

reservadas: ▪ try, catch y throw

Evento que ocurre durante la ejecución de un programa y requiere la ejecución de código fuera del flujo normal del programa.

Una excepción no es necesariamente un error en la ejecución.

Si no implementamos el manejo de excepciones, el programa que se ejecuta será terminado abruptamente.

Las excepciones mas habituales son las peticiones de memoria fallidas.

Síncronas:

Asíncronas:

Aparecen inmediatamente cuando un proceso intenta ejecutar una operación incorrecta.

Aparecen algún tiempo después, en el proceso que intentó la operación errónea o en otro distinto

Hardware:

Software:

ejemplos: error en índice de array, división por cero

Hardware:

Software:

ejemplo: avería en dispositivo externo.

ejemplo: error en comprobación de aserción (condición lógica)

ejemplo: detección de límite de tiempo en una acción de otro proceso

Genera

ció

n

Dete

cció

nD

ete

cció

n

En C++ el manejo de excepciones se basa en tres etapas: Intento de ejecución de código. Si se produce un evento anormal, se “lanza” la

excepción. La ejecución del programa se desvía a un sitio donde la

excepción es “capturada”. La manipulación de excepciones consiste en

transferir la ejecución del programa desde el punto donde se produce la excepción a un manipulador que coincida con el motivo de la excepción.

C++ utiliza las palabras claves try, throw, catch para el manejo de excepciones.

Se especifica un bloque de código cuya ejecución se va intentar utilizando la palabra clave “try”

Si existe una situación excepcional durante el “intento”, se lanza una excepción y se transfiere el control de ejecución al punto donde exista un manejador (“handler”) de excepciones.

En el lanzamiento se crea un objeto que es capturado por el handler. Para cada tipo de error se lanzará un tipo diferente de excepción.

Si no se produce una excepción, el programa sigue el curso normal.

Sintaxis:try{

//bloque de intento; donde se puede producir la excepción}

Se detecta una circunstancia excepcional dentro del bloque “try”; se lanza una excepción mediante la ejecución de la sentencia “throw”.

C++ especifica que todas las excepciones deben ser lanzadas desde el bloque “try”.

Las excepciones son un objeto que contiene información que es capturada por el handler.

El "throw" se comporta como un "return". El valor devuelto por el "throw" se asigna al

objeto del "catch" adecuado. if (condition) throw “exception”;

Parte del programa denominada “manejador” o “handler”. Sitio donde continua el programa en caso de que ocurra

una situación excepcional. Debe existir al menos un manejador inmediatamente

después de un bloque try. Sintaxis:

try {…………….

}catch(<objException>){………….

} Los tipos de la expresión del "throw" y el especificado en el

"catch" deben coincidir. Si no hay un "catch" adecuado, se abandona el programa. Existe un "catch" general, que captura cualquier "throw"

para el que no exista un "catch“.catch(...) { //bloque de instrucciones }

Bloque “try”: Donde se incluye el código que puede

producir la excepción. Uno o varios manipuladores asociados al

bloque "try", cada uno de esos manipuladores empiezan con la palabra "catch", y entre paréntesis una referencia o un objeto

También debe existir una expresión "throw", dentro del bloque "try".

Cuando la excepción es estandar, el throw es implícita.▪ Hay casos en que el "throw" es explícito.

Lo que sucede es lo siguiente: El valor devuelto por el "throw" se

asigna al objeto del "catch" adecuado. En este ejemplo, al tratarse de un

carácter, se asigna a la variable 'c', en el "catch" que contiene un parámetro de tipo “char”.

En el caso del operador “new” si se produce una excepción, se hace un "throw" de un objeto de la clase “std::bad_alloc”. Como no estamos interesados en ese

objeto, sólo usamos el tipo, sin nombre.

El manipulador puede ser invocado por un "throw" que se encuentre dentro del bloque "try" asociado, o en una de las funciones llamadas desde él.

Cuando se produce una excepción se busca un manipulador apropiado en el rango del "try" actual.

Si no se encuentra se retrocede al anterior, de modo recursivo, hasta encontrarlo.

Cuando se encuentra se destruyen todos los objetos locales en el nivel donde se ha localizado el manipulador, y en todos los niveles por los que hemos pasado.

En este ejemplo podemos comprobar que a pesar de haber hecho el "throw" en el tercer nivel del "try", el "catch" que lo procesa es el del primer nivel.

Los tipos de la expresión del "throw" y el especificado en el "catch" deben coincidir, o bien, el tipo del catch debe ser una clase base de la expresión del "throw". La concordancia de tipos es muy estricta, por ejemplo, no se considera como el mismo tipo "int" que "unsigned int".

Si no se encontrase ningún "catch" adecuado, se abandona el programa, del mismo modo que si se produce una excepción y no hemos hecho ningún tipo de manipulación de excepciones. Los objetos locales no se destruyen, etc.

Existe un "catch" general, que captura cualquier "throw" para el que no exista un "catch“.

catch(...) { //bloque de instrucciones }

Clase base "exception" de la que podemos heredar nuestras propias clases derivadas para pasar objetos a los manipuladores.

Declarada en la librería “exception”class exception {

public: exception() throw() { } //constructorvirtual ~exception() throw(); //destrctorvirtual const char* what() const throw();

/*devuelve el motivo de la excepcion*/};

"throw()" sirve para indicar que estas funciones no pueden producir ningún tipo de excepción, es decir, que no contienen sentencias "throw".

Una función recibe el requerimiento de inserción de un número en la posición n de un vector.

La función descubre que n es mayor que el tamaño del vector, por lo tanto lanza o envía un excepción, la cual hace retornar inmediatamente la función al segmento de código llamador.

EL código llamador presumiblemente repite el lazo solicitando un nuevo índice y vuelve a llamar a la función.

La función Insert usa la sentencia throw para retornar tan pronto como se detecta que el índice es muy grande. El throw causa el retorno inmediato de la función.

void Insert( vector<int> & array, int index, int value ){ if( index < 0 || index >= array.size())

throw string("Index out of bounds in Insert()");

array[index] = value;}

// more...

• El bloque try rodea cada sección de código siendo probado.

Una o más sentencias catch siguen al bloque try.

try {cout << "Enter an index between 0 and "

<< (VECSIZE-1) << ": ";cin >> index;Insert( scores, index, value );cout << "Insertion successful.\n";

} catch( string & S ) {

cout << S << endl;}

Podemos definir nuestras propias clases para manejo de excepciones. Ésta define el tipo de objeto lanzado cuando una excepción ocurre.

La clase excepción usualmente lleva por nombre la excepción, por ejemplo RangeException.

class RangeException { };// use for out of range subscripts

Esta versión de la función Insert construye y lanza un objeto RangeException si el índice está fuera del rango.

Paréntesis son requeridos!

void Insert( vector<int> & array, int index, int value ){

if( index < 0 || index >= array.size()) throw RangeException();

array[index] = value;}

Ahora la función llamadora puede nombrar un tipo de excepción específico en la sentencia catch.try {

cout << "Enter an index between 0 and " << (VECSIZE-1) << ": ";

cin >> index;Insert( scores, index, value );cout << "Insertion successful.\n";

}catch( RangeException & ) {

cout << "A range exception occurred.\n";}

Usamos múltiples sentencias catch para atrapar todos los tipos de excepciones que pueden ser lanzadas.

try { DoOneThing(); DoAnother(); DoSomethingElse();}catch( RangeException & ) {

cout << "A range exception occurred.\n";}catch( OpenFileError & ) { cout << "Cannot open file.\n";}// etc...

Una mejor versión de la clase RangeException nos permite pasar un string a su constructor. También hay un método GetMsg que retorna el mismo string.

class RangeException {public:

RangeException(const string & msg){ m_sMsg = msg; }

string GetMsg() const{ return m_sMsg; }

private:string m_sMsg;

};

Cuando la función Insert detecta un índice errado, ésta pasa un string al constructor RangeException.

void Insert( vector<int> & array, int index, int value ){ if( index < 0 || index >= array.size())

throw RangeException("Index out of bounds " "in Insert()");

array[index] = value;}

Cuando el llamador atrapa la excepción enviada por Insert, éste ahora puede llamar GetMsg para desplegar el mensaje almacenado en el string.

try {cout << "Enter an index between 0 and "

<< (VECSIZE-1) << ": ";cin >> index;Insert1( scores, index, value );cout << "Insertion successful.\n";

}catch( RangeException & R ) {

cout << R.GetMsg() << endl;}

Algunas veces es útil lanzar una excepción nuevamente y dejar que la función previa en la cadena se haga cargo de su manejo.

void TestVector(vector<int> & scores,int value){

int index; try {

cout << "Enter an index between 0 and " << (VECSIZE-1) << ": ";

cin >> index;Insert1( scores, index, value );cout << "Insertion successful.\n";

}catch( RangeException & R ) {

throw R;}

} // more...

En este ejemplo la función llamadora debe tener una sentencia catch para atrapar la excepción enviada por TestVector.

void Example2(){ vector<int> scores(VECSIZE); int value = 99;

try { TestVector( scores, value ); }

catch( RangeException & R ) {cout << R.GetMsg() << endl;

}}

Una misma función puede lanzar más de una excepción. Ejemplo:

void Insert( vector<int> & array, int index, int value ){

if( index < 0 || index >= array.size()) throw RangeException("Index out of bounds "

"in Insert()");

if( value < 0 ) throw BadArrayValue();

array[index] = value;}

Si una excepción es lanzada en algún lugar en la cadena de llamados a función y nunca es atrapada, ésta puede ser capturada usando (...) como el parámetro de la sentencia try-catch.void main(){ try { Example2(); } catch( ... ) { cout << "Caught unknown exception in main()\n"; }}

Texto en linea:Eckel, Bruce. Thinking About C++,

2nd Edition, Prentice-Hall, 2000. Gratis en www.bruceeckel.com.

Manejo de Excepciones. Curso ELO329; Prof. Agustin J. Gonzalez;

Universidad Técnica Federico Santa María. http://www.conclase.net/c/curso/

index.php?cap=043 http://www.zator.com/index.htm http://petra.euitio.uniovi.es/

asignaturas/tec.pro/transparencias/manejo.excepciones.pdf

http://msdn2.microsoft.com/en-us/library/t078xe4f(VS.71).aspx