Algortmica y Programacin II Algortmica y Programacin II

Manejo de excepciones
Una excepcin es un evento que ocurre durante la ejecucin de un
programa, e interrumpe el flujo normal de las sentencias.
Muchas clases de errores pueden necesitar manejo de excepciones:
desde serios problemas de hardware, como la rotura de un disco duro, a
los simples errores de programacin, como tratar de acceder a un
Qu es una excepcin?
Algortmica y Programacin II
elemento de un array fuera de sus lmites o una operacin matemtica
errnea. Cuando dicho error ocurre dentro de un programa, debe
controlarse para evitar su finalizacin repentina e inesperada.
En Ada, cuando se produce algn error durante la ejecucin de un
programa, se plantea una excepcin. Dicha excepcin puede provocar la
terminacin abrupta del programa, y es ah donde podemos controlar y
realizar las acciones pertinentes. Tambin se pueden definir nuevas
excepciones que indiquen distintos tipos de error.
Excepciones predefinidas
En Ada existen excepciones predefinidas dentro de algunos paquetes. En el
Standard, tenemos:
Constraint_Error
Este se produce cuando se intenta violar una restriccin impuesta en una
declaracin, tal como indexar ms all de los lmites de un array o asignar a
una variable un valor fuera del rango de su subtipo. Tambin cuando aparece
un valor cero en el divisor de una expresin matemtica.
Algortmica y Programacin II
un valor cero en el divisor de una expresin matemtica.
Program_Error
Se produce cuando se intenta violar la estructura de control, como cuando una
funcin termina sin devolver un valor.
Storage_Error
Esta excepcin es planteada planteada cuando se requiere ms memoria de la
disponible.
Name_Error
se produce cuando se intenta abrir un archivo que no existe.
En el paquete Text_Io:
Data_Error
se produce cuando se ingresa un dato no consistente con su tipo.
Manejador de excepciones
Cuando se espere que pueda presentarse alguna excepcin en parte del
cdigo de un programa, se puede escribir un manejador de excepciones
en las construcciones que lo permitan (bloques o cuerpos de
subprogramas, paquetes), aunque siempre est el recurso de incluir un
bloque en cualquier lugar del cdigo.
Su sintaxis sera:
Algortmica y Programacin II
manejador_excepcin= when [ identificador : ] eleccin_excepcin
{ | eleccin_excepcin } => secuencia_sentencias
eleccin_excepcin ::= identificador | others
A la sentencia que comienza con when se le llama manejador de
excepcin
La palabra reservada others indica cualquier otra excepcin y
debe ser la nica y ltima opcin (manejador universal).
Ejemplos
begin
-- ...
exception
when Constraint_Error =>
Algortmica y Programacin II
Put ("Error de rango.");
when Name_Error | Data_Error =>
Put ("Error en el flujo de datos.");
when others =>
Put ("Otro error.");
end;
Otro ejemplo
function Maana (Hoy: TDa) return TDa is
begin
return TDa'Succ(Hoy);
exception
Algortmica y Programacin II
exception
when Constraint_Error =>
return TDa'First;
end Maana;
Declaracin y planteo de excepciones
Normalmente, es probable prever una situacin de error que no se
encuentra entre las excepciones predefinidas.
Es as como se pueden declarar excepciones. Por ejemplo:
Un_Error: exception;
As, se puede plantear esa excepcin en el momento pertinente mediante
Algortmica y Programacin II
As, se puede plantear esa excepcin en el momento pertinente mediante
una sentencia raise, cuya sintaxis es:
elevacin_excepcin ::= raise [ identificador ] ;
As, en nuestro ejemplo sera:
raise Un_Error;
Veamos el siguiente ejemplo que plantea la accin a realizar cuando se
presenta una situacin errnea en el manejo de una pila implementada
estticamente:
package Pila_enteros is - - especificaciones del paquete
ErrorPilaEnteros: exception;
procedure Poner (X: Integer);
function Quitar return Integer;
end Pila_enteros;
package body Pila_enteros is - - cuerpo del paquete
Max: constant := 100;
Pila: array (1..Max) of Integer;
tope: Integer range 0..Max;
procedure Poner (X: Integer) is
begin
if tope = Max then raise ErrorPilaEnteros; -- Se plantea la excepcin.
Algortmica y Programacin II
if tope = Max then raise ErrorPilaEnteros; -- Se plantea la excepcin.
end if;
tope := tope + 1;
Pila(tope) := X;
end Poner;
function Quitar return Integer is
begin
if tope = 0 then raise ErrorPilaEnteros; -- Se plantea la excepcin.
end if;
tope := tope - 1;
return Pila(tope+1);
end Quitar;
begin
tope := 0;
end Pila_Enteros;
-- una aplicacin podra ser
use Pila_enteros;
begin
Poner (5);
-- ...
exception
when ErrorPilaEnteros =>
-- ... Manipulacin incorrecta de la pila.
when others =>
-- ...
end;
Si no se quiere que el error se propague, pero tampoco se desea realizar alguna accin
Algortmica y Programacin II
Si no se quiere que el error se propague, pero tampoco se desea realizar alguna accin
cuando ste se produce, se puede utilizar la sentencia null. Por ejemplo:
procedure Vaciar_pila_enteros is
Basura: Integer;
use Pila_enteros;
begin
loop
Basura := Quitar;
end loop;
exception
when ErrorPilaEnteros => null;
end Vaciar_pila_enteros;
esto no evitar que se
termine la ejecucin
de la unidad.
No se puede devolver el control a la
unidad donde se produjo la excepcin.
Cuando se termina la secuencia de
Importante 1
Algortmica y Programacin II
Cuando se termina la secuencia de
sentencias del manejador, termina
tambin la ejecucin de dicha unidad.
Ahora bien, si la excepcin est planteada en un bloque perteneciente a
un bucle se puede manejar esta situacin algortmicamente.
Por ejemplo:
Loop --------- comienza el buble
begin --------- comienza el bloque
Importante 2
Algortmica y Programacin II
begin --------- comienza el bloque
Get(A);
Get(B);
if B/=0 then B:=A/B; --------- puede hacerse el calculo
Put(B);
else raise Salida; --------- invoco a la excepcion
end if;
exit when A=0;
exception
when Salida|Data_Error =>Put("no se puede"); --------- o el divisor es cero o se
pulso cualquier tecla no valida
end; --------- fin del bloque
end loop; --------- fin del bucle
Si no se controla una excepcin, sta se
propaga dinmicamente por las
sucesivas unidades invocantes hasta
que se maneje en otra o directamente
Importante 3
Algortmica y Programacin II
que se maneje en otra o directamente
termina la ejecucin del programa
proporcionando un mensaje con la
excepcin provocada por pantalla.
Si se quiere propagar una excepcin despus de haber ejecutado las
sentencias pertinentes, se incluira una sentencia raise dentro del manejador.
Ejemplo:
exception
when ErrorPilaEnteros =>
Put ("Pila utilizada incorrectamente.");
Vaciar_pila_enteros;
raise ErrorProcesamieto; -- Se propaga otra excepcin.
end;
Algortmica y Programacin II
En este caso se propaga otra excepcin, pero podra haber sido la misma
simplemente con raise, sin crear una nueva ocurrencia de la excepcin, por
ejemplo:
-- ...
exception
when Falla_Frenos =>
Put ("Se ha producido un problema en los frenos");
raise; -- Se propaga la misma excepcin del manejador.
end;
El manejo de excepciones debe contemplarse para
evitar una finalizacin no deseada del programa, y
sin duda que los ir incorporando gradualmente a
sus desarrollos. Por el momento, intente considerar
Sntesis
Algortmica y Programacin II
los manejadores estndares que aparecen en la
transparencia #3, y cuando disee y programe los
paquetes de las distintas estructuras de datos,
considere las excepciones pertinentes a cada una.