Agenda Clase 11 Parametrización. Pasaje de parámetros (modos). Razones de escogencia entre modos....

Agenda Clase 11

• Parametrización.• Pasaje de parámetros (modos).• Razones de escogencia entre modos.• Clausuras como parámetros.• Etiquetas, Conformat Arrays, Parámetros por

Default, Parámetros Nombrados.• Número Variable de Argumentos.• Retorno de Funciones.• Módulos y Subrutinas Genéricas.• Casos de Estudio.

Parametrización

•Subrutinas parametrizadas toman argumentos que controlan aspectos de su comportamiento o especifican los datos sobre los que operan.

•Parámetros Formales: aparecen en la declaración de la subrutina.

•Parámetros Actuales: variables y expresiones que son pasadas a la subrutina en el momento de la invocación.

Pasaje de Parámetros (Modos)

• Por Valor: cada parámetro actual es asignado en el parámetro formal correspondiente cuando una subrutina es llamada.

• Por Referencia: cada parámetro formal es un alias del parámetro actual correspondiente.

Razones para escoger un modo

• Si la subrutina invocada debe cambiar el valor del parámetro actual pasaje por referencia. Por valor en caso contrario.

• Nivel extra de indireccionamiento que requiere el pasaje por referencia suele ser menos costoso que copiar el valor cuando los parámetros son grandes.

El Modo READONLY de Modula 3

• Combina la eficiencia del pasaje por referencia y la seguridad del pasaje por valor.

• Impide que los parámetros formales sean alterados por la rutina invocada.

Modos de Parámetros en Ada

• IN: pasan información de la subrutina invocadora a la invocada que puede ser leída por ésta pero no modificada.

• OUT: pasan información del invocador al invocado. Ada 83 permite escribir pero no leer, Ada 95 permite escribir y leer.

• IN-OUT: pasan información en ambas direcciones que puede ser leída y escrita.

Referencias en C++

• Introduce una noción explícita de referencia.

• Los parámetros referenciados se especifican precediendo su nombre con un ampersand (&) en la declaración de la función.

void swap (int &a, int &b) {int t=a; a=b;b=t;}

Referencias en C++

• Cualquier variable puede ser declarada para ser una referencia.

int i

int &j=i j es un alias de i

i=2

j=3

cout << i imprime 3

Clausuras (clousures) pasadas como parámetros• Clausura: referencia a una subrutina + su contexto.• Se utiliza para pasar subrutinas como parámetros,

como en el siguiente ejemplo en Pascal.

procedure apply_to_A(function f(n:integer): integer, var A array [low..high:integer] of integer)

var i integer;begin

for i:=low to high doA[i]:=f(A[i]);

end;

Llamada por nombre en Algol 60

• Es el caso por default para este lenguaje, aunque también admite por valor.

• Se implementa a través de una subrutina oculta que evalúa el parámetro actual en el ambiente de referencia del invocador (denominada thunk).

• Algol 68 eliminó este tipo de llamada por el costo que implica la invocación de un procedimiento thunk por cada parámetro formal.

Etiquetas como parámetros

• Algol 60 y 68 permiten que una etiqueta sea pasada como parámetro.

• Pej: permite saber a dónde debe saltarse cuando se produce el escape de la rutina que se está ejecutando a través de una sentencia go to.

Parámetros de propósito especial: Arreglos Abiertos (Conformant Array)

• Arreglo que es un parámetro formal y cuyo tamaño es determinado a tiempo de ejecución (en un lenguaje que habitualmente determina la forma a tiempo de compilación).

• Se pueden definir arreglos de este tipo en Pascal, Modula-2 y C.

Parámetros por Default

• Parámetros que no necesariamente deben ser provistos por el invocador ya que al no poseerse se utiliza un valor preestablecido.

• Uso común: rutinas de librerías I/O.

• Utilizado por Ada, C++, Common Lisp y Fortran 90.

Parámetros Nombrados (Named Parameters)• Parámetros posicionales los parámetros

actuales en una posición determinada corresponden a los parámetros formales definidos en la misma posición.

• Parámetros nombrados (parámetro acompañado por su nombre formal) pueden ser utilizados en cualquier posición.

put (item => 37, base =>8)

put (base=>8, item=>37)

Número variable de argumentos

• C, C++ y Lisp permiten definir rutinas con número variable de argumentos. int printf(char * format, ...)

• En C y C++ los argumentos no especificados son accedidos a través de macros estándar.

Indica que hay parámetros adicionales en número y tipo desconocido.

Ejemplo en C con número variable de argumentos.#include <stdarg.h> inclusión de librería (macro) para poder

acceder a los argumentos no especificados.int printf(char * format, ...){

va_list args;va_start(args, format);...

char cp=va_arg(args, char);...

double dp=va_arg(args, double);...va_end(args);

}

printf(%c, “hola”) va_args(args, char)

Retorno de Funciones

• En Algol 60 y Fortran deben retornar un escalar.• Pascal y primeras versiones de Modula-2 -

escalar o apuntador.• Algol 68, Ada, C y algunas implementaciones de

Pascal permiten retorno de valores de tipo compuesto.

• Lisp, ML, Modula 3 y Ada 95 permiten retorno de una subrutina implementada como clausura.

• C permite retornar un apuntador a subrutina (no posee clausura ya que no permite anidamiento)

Retorno de Funcionestype int_array is array (integer range <>) of

integer;function A_max (A:int_array) return integer isrtn: integer;begin

rtn:=integer'first;for i in A'first..A'last loop

if A(i) > rtn thenrtn:=A(i);enf if;

end loop;return rtn;

end A_max;

Retorno de Funciones

• En SR:

procedure A_max(ref A[1:*]:int) returns rtn:int

rtn :=low(int)

fa i:= 1 to ub(A) ->

if A[i]>rtn -> rtn:=A[i] fi

af

end

fa indica “for all”bu indica “upper bound”-> indica “do then”

Módulos y Subrutinas Genéricas

• Polimorfismo permite declarar subrutinas en la que los tipos de los argumentos no se encuentran completamente especificados se ahorra el trabajo de escribir varias veces el mismo programa dependiendo de los argumentos que reciba...pero posee algunas desventajas.

• Alternativa crear facilidades genéricas.

Módulos y Subrutinas Genéricas

• Útiles para la creación de containers.

• Los lenguajes que proveen estas facilidades son Clu, Ada (Generic Program Units), C++ (templates) y Modula-3.

• Siguen un mecanismo estático ya que todo lo que requieren puede ser resuelto a tiempo de compilación.

Módulos y Subrutinas Genéricas

• Pueden producir un efecto similar al pasaje de subrutinas en lenguajes donde no esté permitido (como Ada).

generictype item is private;type item_array is array (integer range <>) of item;with function F (it: in item) return item;

procedure apply_to_array(A: in out item_array);

procedure apply_to_array((A: in out item_array) isbegin

for i in A'first..A'last loopA(i) := F(A(i));

end apply_to_array;

Módulos y Subrutinas Genéricas

• Dado que una unidad de programa genérico es una abstracción, es importante que su interfaz (cabecera de la declaración) provea toda la información que debe ser conocida por el usuario de la misma.

• Clu y Ada refuerzan la regla anterior obligando que las funciones sean explícitamente declaradas.

• En C++ y Modula-3 por el contrario se pueden aplicar operaciones de forma arbitraria aunque esto producirá error semántico estático.