1. 5.4 Manejo de Excepciones

2. Manejo de excepciones
• El manejo de excepciones de C++ se
centra alrededor del uso de la palabra
reservada try y de la palabra
reservada catch.
Mtl. Lourdes Cahuich 2

3. Manejo de excepciones
• Un programador incluye código que
puede activar una excepción dentro de
un bloque try.
• Uno o varios bloques de catch
inmediatamente siguen al bloque de
try excepción
Mtl. Lourdes Cahuich 3

4. Manejo de excepciones
• Cuando una excepción ocurre en un
bloque de try, el punto de ejecución
del programa es transferido al bloque
de catch que corresponda al tipo de
excepción arrojada.
Mtl. Lourdes Cahuich 4

5. Manejo de excepciones
• El bloque de catch ejecuta las tareas
necesarias para una recuperación de la
condición de excepción .
• En otras palabras, “maneja” la
excepción
Mtl. Lourdes Cahuich 5

6. #include <iostream>
#include <cstdlib>
#include <stdexcept>
using namespace std;
void calculate_fibonacci(int);
int main(int argc, char* argv[]) {
try {
if (argc != 2) {
cerr << quot;Usage: quot; << argv[0] << quot; numquot; << endl;
return EXIT_FAILURE;
}
int number_fib = atoi(argv[1]);
calculate_fibonacci(number_fib);
return EXIT_SUCCESS;
}
catch (exception& e) {
cerr << e.what() << endl;
}
return EXIT_FAILURE;
}
void calculate_fibonacci(int number_fib) {
int* array = new int[number_fib];
array[0] = 1;
array[1] = 1; // populate the elements with Fibonacci numbers
for (int i = 2; i < number_fib; i++) {
array[i] = array[i - 1] + array[i - 2];
}
delete [] array;
Mtl. Lourdes Cahuich 6
}

7. Manejo de excepciones
• Se activan las excepciones utilizando el
estatuto throw.
• En un estatuto throw, un programador
especifica la excepción a activar
después de la palabra throw.
Mtl. Lourdes Cahuich 7

8. Manejo de excepciones
• En C++, una variable de cualquier tipo
de dato puede ser arrojada como una
excepción utilizando el estatuto throw.
• Esto difiere de Java, donde solo objetos
y descendientes del tipo
java.lang.Throwable pueden ser
arrojados y atrapados.
Mtl. Lourdes Cahuich 8

9. Manejo de excepciones
• C++ puede arrojar objetos de clases
definidas por el usuario, objetos de
clases estándar (como aquellos de la
clase string), e inclusive variables de los
tipos de datos fundamentales.
• En C++ se crean clases de excepción
definidas por el usuario.
Mtl. Lourdes Cahuich 9

10. Manejo de excepciones
• Un bloque de catch cuyo argumento
contiene elipsis atrapa todas las
excepciones.
• Esto es útil en situaciones donde un
programador quiere asegurarse de que
todas las posibles excepciones son
atrapadas.
Mtl. Lourdes Cahuich 10

11. Manejo de excepciones
• Una excepción no manejada puede
causar la terminación anormal de una
aplicación.
Mtl. Lourdes Cahuich 11

12. int main(int argc, char* argv[]) {
try {
if (argc == 1) {
throw runtime_error(quot;runtime errorquot;);
}
if (argc == 2) {
throw out_of_range(quot;out of rangequot;);
}
if (argc == 3) {
throw length_error(quot;length errorquot;);
}
return EXIT_SUCCESS;
}
catch (...) {
cerr << quot;An exception was caught!quot; << endl;
}
return EXIT_FAILURE;
}
Mtl. Lourdes Cahuich 12

13. La Jerarquía Estándar de Excepción de
C++
• La biblioteca estándar de C++ provee y
utiliza una jerarquía estándar de clases
de excepción.
• Las clases contenidas en esta jerarquía
son arrojadas por varios componentes
del lenguaje C++, la biblioteca estándar
y la biblioteca de plantillas estándar
Mtl. Lourdes Cahuich 13

14. Mtl. Lourdes Cahuich 14

15. La Jerarquía Estándar de Excepción de
C++
• Las excepciones bad_alloc y
out_of_range son dos excepciones
estándar a las que ponemos cuidadosa
atención en este curso.
• La excepción bad_alloc es arrojada
por el operador new cuando la memoria
no puede ser provista en la forma en la
que es requerida.
Mtl. Lourdes Cahuich 15

16. La Jerarquía Estándar de Excepción de
C++
• La excepción out_of_range es
arrojada por la función miembro at del
tipo vector, cuando se solicita un
elemento cuyo índice está fuera de
alcance
Mtl. Lourdes Cahuich 16

17. La Jerarquía Estándar de Excepción de
C++
• Los programadores pueden extender la
jerarquía estándar de excepción
definiendo sus propias clases de
excepción que heredan de una de las
clases estándares de excepción.
Mtl. Lourdes Cahuich 17

18. Como Usar los Manejadores Intermediarios
• Los manejadores de excepción intermediarios
son manejadores de excepción que atrapan
una excepción, libera algunos recursos e
inmediatamente después vuelven a arrojar la
excepción.
• Los manejadores de excepción intermediarios
son utilizados para asegurar que toda la
memoria asignada sea propiamente liberada
aún y cuando el programa pase el control a
un manejador de excepciones.
Mtl. Lourdes Cahuich 18

19. Como Usar los Manejadores Intermediarios
• Esto se torna complicado cuando
consideramos que una excepción puede
causar que un programa transfiera el
control a un bloque de catch en una
rutina diferente
Mtl. Lourdes Cahuich 19

20. #include <iostream>
#include <cstdlib>
#include <stdexcept>
using namespace std;
void method_two() {
throw out_of_range(quot;out of rangequot;);
}
void method_one() {
int *array = new int[100];
method_two();
delete [] array;
}
int main(int argc, char* argv[]) {
try {
method_one();
return EXIT_SUCCESS;
}
catch (exception& e) {
cerr << e.what() << endl;
}
catch (...) {
cerr << quot;Unknown exception!quot; << endl;
}
return EXIT_FAILURE;
Mtl. Lourdes Cahuich 20
}

21. Como Usar los Manejadores Intermediarios
• El listado que se acaba de mostrar ilustra la
dificultad que introduce el manejo explícito de
memoria al manejo de excepciones y porque
necesitamos manejadores intermediarios de
excepciones.
• Se incluye una función method_one que
asigna un arreglo entero en memoria.
• Antes, method_one libera este arreglo, la
función llama a method_two.
Mtl. Lourdes Cahuich 21

22. Como Usar los Manejadores Intermediarios
• La función method_two
inmediatamente arroja una excepción.
• El control es entonces transferido al
más cercano y apropiado bloque de
catch.
Mtl. Lourdes Cahuich 22

23. Como Usar los Manejadores Intermediarios
• Sin embargo, este bloque de catch
existe en la función main.
• La transferencia de control a este
bloque de catch se salta la ejecución
del estatuto delete [] en
method_one.
• Esto resulta en una pérdida de
memoria.
Mtl. Lourdes Cahuich 23