Unidad V

Subprogramas

Procedimientos y funciones. Características. Invocación.

Recordar concepto de ABSTRACCIÓN: mecanismo fundamental del razonamiento humano para manejar la complejidad de
las cosas, que consiste en prestar atención solamente a aquellos que se consideran relevantes/importantes a un tema, dejando de
lado a los detalles que pueden considerarse secundarios. Se puede clasificar en:
• Aplicada a las operaciones necesarias para resolver un problema, en cuyo caso se denomina ABSTRACCIÓN
FUNCIONAL o DE PROCESOS.
• Aplicada a la representación de los datos necesarios para resolver un problema, en cuyo caso se denomina
ABSTRACCIÓN DE DATOS.
------------------

Subprogramas (o unidades): son bloques de instrucciones o porciones de código que resuelven un subproblema bien definido
dentro de un programa. De esta manera el programador puede dividir un problema en subproblemas y concentrarse en qué
parte del problema global se resuelve con cada subproblema y luego desentenderse de cómo lo hace.
• Un programa se compone de un solo programa principal, el cual, durante la ejecución, puede llamar a varios
subprogramas, los que a su vez pueden llamar otros sub-subprogramas, y así sucesivamente. Se espera que cada
subprograma termine su ejecución en cierto punto y regrese el control al programa que lo llamó.
• Durante la ejecución de un subprograma, la ejecución del programa que lo llamó se detiene temporalmente. Cuando
se completa la ejecución del subprograma, la ejecución del programa que lo llamó se reanuda en el punto que sigue de
inmediato a la llamada del subprograma1.
• La principal ventaja es que permite factorizar bloques de instrucciones, y de esta manera se aumenta la eficiencia de
la estrategia de solución, dividiendo un problema grande en mas pequeños y facilitando agregar nuevas
funcionalidades al programa. Además, la factorización aumenta la eficiencia del código y su legibilidad, facilidad de
escritura y detección de errores.
• También permite soportar la metodología de diseño top-down, mejorando la legibilidad.

• Otras características de los subprogramas:

◦ Permite reutilizar código, ahorrando memoria y tiempo de codificación.
◦ Cada subrpograma tiene un solo punto de entrada.
◦ Puede modificar el ambiente de la unidad llamadora (parámetros in-out).
◦ La unidad llamadora suspende su ejecución durante la ejecución del bloque llamado. No vuelve a ejecutarse hasta
que le devuelvan el control (ver 1).

• Existen dos categorías de subprograma: procedimiento o función.

◦ Procedimiento: abstracción procedural que al ser invocada evalúa una o varias instrucciones y modifica su
propio ambiente y eventualmente el de la llamada (si es posible). Los resultados devueltos NO se asocian a su
nombre.
▪ Son conjuntos de sentencias que son convocados por un simple llamado o sentencia call.
▪ Es un mecanismo en un lenguaje de programación para abstraer un grupo de acciones o de computaciones.
▪ El grupo de acciones se conoce como el cuerpo del procedimiento, que está representado por el nombre del
procedimiento. Un procedimiento se define con una especificación o interfaz y un cuerpo. La especificación
le da nombre al procedimiento, una lista de los tipos y nombres de sus parámetros.
▪ Se llama (invoca) o activa un procedimiento al enunciar su nombre, junto con los argumentos de la llamada,
que corresponden a sus parámetros.
▪ Una llamada a un procedimiento transfiere el control al principio del procedimiento llamado. Cuando la
ejecución llega al final del cuerpo, el control es devuelto al llamador. En algunos lenguajes, puede devolverse
el control al llamador antes de llegar al final del cuerpo utilizando un enunciado return.
1 Se pueden dar el hecho de subprogramas paralelos o concurrentes a un programa principal, en cuyo caso no se cede el control sino que trabajan al mismo
tiempo, llamador y llamado. Cuidado con meterse en este lado.

1
 ▪ Un procedimiento se comunica con el resto del programa a través de sus parámetros y también a través de
sus referencias no locales. Es decir, (a diferencia de las funciones, no devuelven un valor) generan resultados
en variables visibles en el subprograma y en el programa, o a través del uso de parámetros.

◦ Funciones: unidad que evalúa una expresión y al ser invocada produce un resultado.
▪ A diferencia del procedimiento, la función retorna un valor resultado. Es decir, que en su definición, la
interfaz o especificacion, además del nombre o identificador y los parámetros, también se define el tipo de
valor de retorno. Adicionalmente, las funciones son subprogramas dentro de un programa que se puede
invocar (ejecutar), desde cualquier parte del programa, es decir, desde otra función, desde la misma función
(funcion recursiva, por Ej., para calcular el factorial de un numero) o desde el programa principal.

• Diferencias entre función y procedimiento:

◦ Mientras que llamada a una función es invocada siempre desde una expresión (x = fun Algo(x);), la llamada a un
procedimento es una instrucción que por si sola no necesita instrucciones (es decir, puede aparecer como una
instruccion independiente), es decir, se llama desde un enunciado (proc algo (int b)).
◦ El procedimiento se declara igual que la función, pero su nombre no está asociado a ninguno de los resultados
que obtiene. Además, la declaración de una función debe incluir el tipo de dato que se devolverá.
◦ Las funciones devuelven un valor mientras que los procedimientos pueden devolver 0, 1 ó n valores.

2
Invocación.

La invocación es un llamado explícito a la ejecución de un subprograma.

• Se plantea una visualización del sistema organizado unidades jerárquicas.
• Un subprograma se considera “activo” cuando se encuentra en ejecución.
• El mecanismo básico de ejecución de subunidades es:
◦ Una unidad cede el control mediante una llamada call, se asocian parámetros a esa llamada y se suspende la
ejecución.
◦ Se ejecutan las instrucciones del subprograma hasta el final. Se devuelven resultados, si es que existen.
◦ Se cede el control a la instrucción siguiente a la que hizo la llamada.

Por cada invocación se crea el registro de activación, el cual refleja el estado actual del subprograma y consiste en una pila que
contiene la dirección de retorno, el enlace estático, el enlace dinámico, los parámetros y las variables locales (esta estructura
cambia dependiendo de cómo el lenguaje haga el manejo de memoria; ver U8). (La manera de implementar este esquema es
mediante estructuras llamadas registros de activación y teniendo cargado en memoria además la versión ejecutable de esa
unidad -área de código-)

---------
Registros de Activación2: estructuras que existen en tiempo de ejecución y que contienen toda la información necesaria para
la ejecución de un determinado subprograma. Se crea al momento en que empieza a ejecutarse y se destruye cuando termina
(en los lenguajes que manejan la memoria con basados en pila, o dinámicos en heap).
• Estructura y composición del registro de activación: los RA se van guardando en una pila y los datos que
contienen son:
◦ Resultado de la Función (RF): en donde se almacena el valor de retorno. Es con lo que la unidad llamadora
altera el ambiente de la unidad llamada. Lo que en el gráfico de arriba sería la flecha con el flujo que traspasa los
resultados.
◦ Enlace Dinámico (ED): puntero que nos indica en que posición de la pila termina el RA de la unidad llamadora
y el nombre del RA. Este puntero nos permite seguir la secuencia de flujo de llamado de los subprogramas
establecidas en tiempo de ejecución. Nos permite armar el ambiente de referenciamiento de la unidad y actualizar
el CEP ante cualquier cambio en el mismo.
◦ Enlace Estático (EE): contiene el nivel o grado de anidamiento. Cuando se ingresa a un subprograma, el nivel de
anidamiento aumenta y cuando se sale, disminuye. El nivel de anidamiento nos indica la cantidad de antepasados
estáticos que se tienen. Este puntero nos permite tener la estructura de los subprogramas conformadas en tiempo
de compilación.

2 Esto solo se nombra en filminas, y corresponde en realidad a la U8. CUIDADO CON METERSE MUCHO CON ESTO ACÁ.

3
 ◦ Dirección de retorno (DR): contiene la dirección de la última instrucción ejecutada en la unidad llamadora. Nos
sirve para actualizar el CIP ante cualquier cambio. Una vez que se crea o se destruye un RA, el CIP modifica su
contenido en función de lo que contenga este puntero en el RA que esté activo en ese momento.
◦ Parámetros Formales (PF): son inicializados por la unidad llamadora siguiendo la política de algún
determinado método (o semántica) de pasaje de parámetros (por valor, referencia, nombre, Etc.)
◦ Variables locales (VL): en esta área se almacenan todas las variables que se crean al momento en que se invoca
al subprograma.
◦ Además existen para todos los RA dos punteros más, los cuales comparten:
▪ CIP (Counter Instructión Point): contiene la dirección de la última instrucción ejecutada en la unidad
llamadora.
▪ CEP (Counter Enviroment Point): contiene el RA que está activo en ese momento.

Dirección de cada instrucción e

instrucciones ejecutables

Constantes locales al bloque

ÁREA DE CÓDIGO

--------------------------------

ELEMENTOS EN LA DEFINICIÓN DE SUBPROGRAMAS.

La estructura común de un subprograma es:

• Encabezamiento (header): es la primer línea de definición de un subprograma e inicia con alguna palabra especial.
Aparte de eso, se especifica el nombre del subprograma, una lista de parámetros (si lo requiere), valores de retorno (el
encabezado de un subprograma es algo muy particular en cada LP, no se puede generalizar mucho, las sintaxis son
distintas).
• Cuerpo: van las declaraciones y los bloques ejecutables (pueden ir llamadas a otros subprogramas, si el LP lo
permite).
• Firma y Protocolo: especifica cómo debe realizarse la comunicación de parámetros y resultados (tipo y orden de los
parámetros y, opcionalmente, valor de retorno)
Ejemplos: Dnó.

Pasaje de parámetros. Semántica. Pasaje por copia de valor, por referencia y por nombre.

• Existen dos tipos de comunicación:

◦ la comunicación implícita, mediante el uso de variables globales.
◦ La comunicación explícita, a través de los parámetros formales y reales.
• Los parámetros formales son los que figuran en el header o encabezamiento (es la primera línea de definición de un
subprograma), y los reales son los que figuran en la sentencia de invocación.
• Los parámetros pueden ser cualquier tipo de estructura: variables, constantes, arreglos, componentes de arreglos,
subprogramas, registros, Etc.

Pasaje de parámetros. Especifican la forma en que las entidades son transferidas hacia y desde unidades llamadas.

Existen tres Modelos Semánticos de pasaje de parámetros:

• Semántica In Mode: el flujo de información va desde la unidad llamadora hacia la unidad llamada. Es un parámetro
que solo sirve para ingresar información a la unidad invocada. Es decir, solo se pueden recibir entidades de los
parámetros reales.
• Semántica Out Mode: flujo inverso. Estos parámetros solo sirven para extraer información de la unidad llamada
hacia la llamadora. Es decir, solo se transmiten entidades a los parámetros reales.
• Semántica In-Out Mode: permite el flujo en ambas direcciones. La mayoría de los LP toman a esta por defecto, es
decir que si no se especifica nada, se toma al parámetro como in-out mode. Es decir, se pueden recibir y transmitir.

4
En base a esto, se plantean tres modelos3 de implementación de pasaje de parámetros: por copia, por referencia y por
nombre, que establecen las diferentes maneras que tienen de inicializar los PR a los PF y la forma de relacionarse unos con
otros:
• Por copia: En los pasajes de parámetros por copia, los parámetros formales no comparten el área de almacenamiento
con los parámetros reales, sino que se tratan como variables locales. Es decir, todos los parámetros se copian en otra
área de memoria. Existen dos áreas de almacenamiento independientes. Una con los PR y otra con los PF. Los PR
“copian” su contenido en los PF. Se plantean 3 posibilidades:
◦ Por valor (Sebesta, "Pass-by-Value"): El valor del parámetro real es utilizado para inicializar el
correspondiente parámetro formal. Por lo tanto, utiliza semántica in-mode (el parámetro formal solo recibe un
valor del parámetro real), no permitiendo ningún flujo de información hacia la unidad llamadora. La
modificación de los parámetros formales no afecta a los parámetros reales. EJEMPLO, un subprograma que
recibe una String y lo muestra por pantalla alterado (sin modificarlo realmente).
◦ Por resultado (Sebesta, "Pass-by-Result"): los parámetros formales se tratan como variables locales y cuando
finaliza la ejecución, los valores de los parámetros formales se copian a los parámetros reales. Por lo tanto,
cualquier modificación que se haga altera el ambiente de la unidad llamadora. La semántica es out-mode
(devuelve un resultado y altera el ambiente de referenciamiento). EJEMPLO, yo lo asocio con un procedimiento
que te modifica una variable global o algo así (tipo, lo llamás sin parámetro y te modifica algo en base a algo).
◦ Por valor-resultado (Sebesta, "Pass-by-Value-Result)": se combinan los dos anteriores, es decir, que primero
se copian los valores de los parámetros reales en los parámetros formales y al finalizar copia los parámetros
formales en los reales. Por lo tanto la semántica en este tipo es inout-mode. ← Pensar que es igual al pasaje por
referencia, pero creando una copia y devolviendo el resultado.
• Por Referencia: La unidad llamadora le pasa a la unidad llamada la dirección del parámetro real. Se convierte
entonces en una variable compartida y cualquier modificación afecta al ambiente de la unidad llamadora. La
semántica utilizada es entonces inout-mode.
• Por Nombre: es similar a pase por referencia pero la diferencia es que la ligadura entre el parámetro real y formal no
se establece en el momento de la llamada sino cada vez que el parámetro formal es referenciado. Como consecuencia,
cada referencia a los parámetros formales puede quedar ligada a diferentes datos. Tambien el modelo semántico es
inout-mode.

3 Sebesta no agrupa; tira 5 implementaciones: pasaje por valor, pasaje por resultado, pasaje por valor-resultado, pasaje por referencia, pasaje por nombre.
Es lo mismo, pero acá se agrupan las tres primeras en "Copia de...".

5
Ejemplo: Sea el programa PROG que llama la ejecución de un subprograma SUBP:

PROG ( ) { SUBP ( int i , int * j ) {

int a, b ; i = i + 10;
a = 2; * j = * j + 10;
b = 3; printf (“I=%d; j=%d\n”, i,*j);}
SUBP ( a, &b );
printf (“%d%d \ n”, a, b); }

 El subprograma SUBP, codificado en C, muestra dos parámetros formales:

• i: transmitido por valor.
• j: transmitido por referencia (por el asterisco antepuesto).

Subprogramas como parámetros.

Es conveniente, a veces, pasar unidades como parámetros. Surgen en estos casos algunos aspectos de diseño que deben
considerarse:
• Decidir si se controlara el tipo de los parámetros .
• Decidir cual será el ambiente de referenciamiento para el subprograma pasado como parámetro .
◦ Superficial (shallow binding): el ambiente de referenciamiento de la instrucción de llamado (al parámetro) lo
determina.
◦ Profundo (deep binding): el ambiente de la definición de la unidad llamada
◦ Ad‐hoc: el ambiente de la sentencia de llamado que pasa la unidad
Algunos lenguajes controlan el tipo de los parámetros, por ejemplo Fortran. En C y C++ no se pueden pasar unidades como
parámetro, pero si punteros a unidades. En este último caso se hace chequeo de tipos. Ada no permite pasar unidades como
parámetros . Ejemplo:

Subprogramas genéricos. Subprogramas sobrecargados.

• En muchas situaciones un mismo problema se plantea en contextos diferentes, de forma que el algoritmo que lo
resuelve es el mismo, salvo por los detalles propios de cada contexto; por ejemplo, si se quiere ordenar un array, las
acciones que habrá que realizar son las mismas independientemente del tipo de los elementos del array (siempre que
sean ordenables), o incluso de su número de componentes.
• Un subprograma (o unidades) genérico es aquel que implementa el mismo algoritmo, pero actúa sobre diferentes tipos
de datos en los parámetros. De esta forma se obtiene la gran ventaja de la reusabilidad del software.
• Una unidad genérica se compone de una declaración genérica de los parámetros (generic_declaration) y un cuerpo,
que es igual que el de cualquier unidad no genérica (cualquier función o procedimiento).
• Una vez se tiene escrito el subprograma genérico, se pueden declarar instancias del mismo con diferentes parámetros
reales genéricos, lo que hará que el compilador cree los subprogramas correspondientes.

< tipo unidad > < nombre de la instancia> is new < nombre unidad genérica> (< parámetros reales genéricos > );

6
 • Ada permite crear unidades genéricas. Para ello basta anteceder la unidad correspondiente con la palabra "generic";
los parámetros formales de la unidad se sitúan en la zona comprendida entre la palabra "generic" y el comienzo de la
unidad propiamente dicha. Vemos un ejemplo para el caso de un procedimiento genérico:

generic
type TElemento is private;
procedure Algo(Elemento:in TElemento) is
--Declaraciones
begin
--Acciones
end Algo;

Para utilizar el procedimiento "Algo" primero se deberán crear instancias con diferentes parametros reales:
procedure Algo_entero is new Algo(TElemento=>integer);
procedure Algo_carácter is new Algo(character);

Ahora, ya se pueden invocar los procedimientos "Algo_entero" y "Algo_carácter", según convenga:

Algo_entero(30);
Algo_carácter('a');

• Al tomar parámetros de diferentes tipos de datos en las distintas activaciones, son llamados subprogramas
polifórmicos: existen dos tipos de polimorfismo.
◦ UNIVERSAL
▪ Por inclusión: es el que se obtiene del modelado de subtipos y herencia. Un objeto es visto como
perteneciente a varias clases, no necesariamente disjuntas
▪ Paramétrico4: las funciones o datos poseen un tipo parametrizado. Las funciones de este tipo son llamadas
también genéricas. Una función genérica trabaja con diferentes tipos de datos, realizando las mismas
acciones independientemente del tipo. // El código no incluye ningún tipo de especificación sobre el tipo de
datos sobre el que se trabaja. Así, puede ser utilizado a todo tipo de datos compatible. (Asociar con el <?>
de Java, que hacía llamadas a métodos especificos del tipo, pero de manera genérica, como el toString -o
sea, el genérico llamaba al toString del tipo <?>, que en posteriormente se convertía en un tipo real; ese
tipo real tenía que tener definido del alguna manera el método toString)
◦ AD HOC (aparente)
▪ Sobrecarga: diferentes subprogramas con el mismo nombre donde las combinaciones de tipos deben ser
especificadas individualmente antes de usarse. Y a partir del tipo de los parámetros reales, el compilador va a
saber resolver a cual version de subprograma corresponde (a cual se los subprogramas de mismo nombre se
esta llamando).
▪ Coerción: en donde se realiza una conversión de tipos para poder realizar una tarea determinada.

Estructuras de control a nivel subprogramas: jerarquía, simétrica, planificadas, concurrentes, excepciones y eventos.

• En cuanto a las estructuras de control a nivel de subprogramas los lenguajes varían sustancialmente en las facilidades
que brindan para controlar el flujo de ejecución.
• Las transferencias de control entre unidades pueden ser:
◦ Explicitas, que son las que establece el programador.
▪ Jerárquica: la unidad llamadora queda subordinada a la unidad llamada. La última no le devuelve el control
hasta que haya terminado con su ejecución. Ejemplos: procedimientos y funciones en C, Pascal y Ada.
• Puede, entremedio, llamar a otra unidad y se repite el proceso. Es decir, que permite recursividad.
Cuando una unidad se define recursivamente en ejecución vuelve a ser activada antes de que la
activación anterior termine, lo que requiere mayor soporte en ejecución. (Se guarda el ambiente de
referenciamiento cuando se hace una llamada y se destruye cuando termina.) ← Recordar que solo es
posible en basados en pila y dinámicos en heap.
▪ Simétrica: las unidades simétricas pueden verse como un grupo de unidades que se activan unas a otras
explícitamente, generando una ejecución entrelazada de acuerdo a un patrón predefinido. Es decir, se ve
como una ejecución entrelazada. Ideal para concurrencia con corrutinas. Es utilizado en los SO multiproceso.
Utilizado utiliza esto Simula 67 con la corrutinas, invocando la corrutinas mediante la palabra Resume.
• Corrutinas: Si A llama el subprograma B como corrutina con resume B, B se ejecuta un tiempo y regresa
el control a A, justo como lo haría cualquier subprograma ordinario. Cuando A pasa de nuevo el control
a B a través de un resume B, B se ejecuta otra vez por un tiempo y regresa el control a A.
• Ambiente de referenciamiento sensible a la historia. Se mantiene el ambiente de referenciamiento, de lo
4 Este es el que representa a las unidades genéricas.

7
 contrario sería genérico.
• Se utilizan en excepciones (corrutinas). No desaparecen los registros de activación, hasta que termine de
ejecutarse la corrutina). ← Cuidado.

▪ Planificada: utilizada por lenguajes para simulación (Simula), que permite planificar el momento de
ejecución de un subprograma, como la ejecución después de otro (call subA after subB), o que inicie su
ejecución condicionado por una expresión booleana (call subA when var=true), o en base a una escala de
tiempo (call subA at time=50) o de acuerdo a las prioridades (call subA with priority 10).
▪ Paralela: se ejecutan dos procesos o dos unidades de manera simultánea. La concurrencia puede ser física
(si hay mas de un procesador) o lógica -es decir, simulada en un solo procesador- permite al programador y
al software de aplicación suponer la existencia de múltiples procesadores. El software se puede diseñar de
manera que se simule la presencia de múltiples hilos de control).
• Cuando un proceso no se comunica con otros o no los afecta se dice que es disjunto. Pero cuando se trata
de procesos que se comunican y comparten información se debe tener mucho cuidado de sincronizar los
procesos para que se ejecuten de manera ordenada. Es decir, se requiere de un mecanismo que permite el
control tanto del orden en que se ejecutan los procesos, como de los datos compartidos.
• Existen dos tipos de sincronización: cooperativa y competitiva. La sincronización se refiere a los
mecanismos que permiten al programador controlar el orden relativo en el cual las tareas/hilos se
ejecutan.
◦ Cooperativa: la tarea A debe esperar que la tarea B complete (termine) una actividad específica
antes que la tarea A puede continuar su ejecución. Es decir, un proceso debe esperar el fin de otro
proceso que utiliza un recurso que necesita. Ejemplo el problema productor ‐consumidor. Un
proceso almacena datos en un buffer, y otro lo vacia.
◦ Competitiva: un proceso debe esperar que otro proceso libere un recurso que necesita. (Dos o mas
tareas deben usar un recurso que no puede ser utilizado en forma simultánea.) (Exclusion mutua)
(Ej., un contador compartido)
• Los metodos que se utilizan para el control de recursos compartidos son: el semáforo, el monitor y el
pasaje de mensajes.
◦ Semáforos: es una estructura de datos que consiste en una variable entera S (llamada semáforo) que
indica si un recurso está disponible o no, sujeta a dos operaciones: wait y signal, y una cola para
almacenar descriptores de tarea. Estas operaciones se ejecutan de manera indivisible. Cuando un
proceso modifica el valor del semáforo, otros procesos no pueden modificarlo simultáneamente.
▪ Se inicializa con valor no negativo. S=1.
▪ Wait decrementa el valor del semáforo. Si el valor se hace negativo, el proceso se bloquea, es
decir que ya se esta usando el recurso, entonces se almacena en un cola.
▪ Cuando el proceso termina, se ejecuta Signal.
▪ Signal incrementa el valor del semáforo. Y si hay otro en cola, se ejecuta Wait.
▪ (Nota: ExclusionMutua: Un recurso solo puede usarlo un proceso a la vez: es no compartible.
Si otro proceso requiere el recurso tiene que esperar a que el proceso que lo tiene lo libere)
◦ Monitores: la idea es encapsular los datos compartidos para restringir el acceso. Un monitor es un
tipo de dato abstracto para datos compartidos. Muchos lenguajes proveen la facilidad de definir
monitores, algunos de ellos son: Concurrent Pascal, Ada, Java. Los datos están ahora dentro del
monitor en lugar de en las unidades clientes. Las llamadas a las unidades del monitor son
implícitamente encoladas si el monitor está ocupado en el momento de realizar la llamada.
◦ Pasaje de mensajes: es utilizado en sistemas distribuidos, donde un proceso envía mensaje a un
buzón compartido, y el otro proceso lo lee. Lo usa Ada.

8
 ◦ Implícitas, que son las manejadas por el LP. ← Continuación de “Transferencia de control”.
▪ Manejo de excepciones: una excepción es un evento inusual, que representa diversas condiciones de error o
situaciones anomalas (como una division por cero o la lectura de un archivo de formato incorrecto), y que
necesita un manejo especial. Algunos lenguajes brindan mecanismos para definir unidades que se invocan
implícitamente. Estos mecanismos permiten al programador manejar excepciones que controlarán
situaciones fuera de rutina.
• Algunas situaciones anómalas podrían ser las siguientes:
◦ Condiciones de error: división por cero, operación fuera de rango, acceso a componentes fuera de
rango.
◦ Condiciones impredecibles: lectura de registros sin el formato especificado.
• Cuando se construye un programa, con frecuencia el lugar donde ocurre una excepción no es el mejor
lugar para manejarla. Considerar dentro de un algoritmo todas las posibles situaciones que podrían
darse, compromete la legibilidad y comprensión del programa. Es por ello que algunos lenguajes
brindan mecanismos para remover el tratamiento de estas cuestiones del programa principal, de manera
tal que puedan ser consideradas independientemente de la solución en otro subprograma.
• Cuando ocurre una excepción, la ejecución del programa se interrumpe, y se pasa el control al
manejador de excepciones correspondiente según el tipo de excepción. Básicamente es un subprograma
que realiza algún procesamiento que permita luego continuar la ejecución del programa normalmente.
• Después de que un manejador completa el procesamiento de una excepción, existe una duda constante
en cuanto a dónde se va a transferir el control porque no hubo una llamada explícita del manejador
◦ ¿Debe volver el control al punto donde se planteó la excepción (el cual puede estar a varios niveles
de subprogramas de distancia)?
◦ ¿Debe volver el control al enunciado del subprograma que contiene el manejador donde la
excepción se planteó después de propagarse?
◦ ¿Debe terminarse el subprograma que contiene el manejador mismo, pero terminarse de manera
normal, para que parezca al que lo llamó como si nada hubiera ocurrido?

CUESTIONES DE DISEÑO DEL MANEJADOR DE EXCEPCIONES (filmina)5

• Posibilidad de que el usuario pueda definir las especificaciones de una excepción.
◦ Excepciones por defecto.
◦ Habilitar/Deshabilitar.
• Bloque de manejo de excepciones separado del programa, o integrado en el código.
• Retorno:
◦ A la misma sentencia (riesgo bucle infinito de error).
◦ A la sentencia siguiente (riesgo de inconsistencia)
◦ Al fin de la unidad (riesgo de perder eficacia)
◦ A una etiqueta determinada.

5 Sebesta plantea más.

9
10