Geradem

F Con enlace dinámico, una ocurrencia de aplicación de un identificador se asocia con la ocurrencia de enlace del bloque
F La instanciación ocurre inmediatamente luego de definirse una clase.
F Si un lenguaje obliga a la definición de tipos por porte del programador, el control de tipos puede ser estático o dinámico
V El ocultamiento de información permite el desarrollo independiente y en paralelo de aplicaciones
V El polimorfismo de inclusión se sustenta en la relación de herencia entre clases
V El valor almacenado en un atributo de clase es compartido por todas las instancias de la clase a la que pertenece dicho atributo
F En el mecanismo de paso de parámetros por valor, el argumento debe ser una variable
V En el paradigma funcional no existen asignaciones de variables ni estructuras iterativas.
F En un desarrollo modular es muy deseable tener módulos con una cohesión mínima y altamente acoplados
V En un método de clase no pueden accederse a atributos de instancia.
V La agregación es una relación entre objetos en donde el tiempo de vida del objeto incluido es independiente del que lo ……………
V La declaración de un identificador en un bloque M, lo hace visible en todos los sub bloques internos a M
F La evaluación impaciente evalúa el parámetro actual en la llamada a la abstracción solo cuando lo necesita
F La evaluación perezosa evalúa el parámetro actual en la llamada a la abstracción.
V La evaluación perezosa no evalúa un parámetro si no se lo necesita.
V Las características públicas de una clase de denomina interfaz de la misma.
F Las clases que heredan características de una clase abstracta no pueden servir como base para definiciones de otras clases
V Un identificador u operador se sobrecarga cuando tiene varias abstracciones asociadas al mismo.
F Una característica oculta de una clase (privada) no puede accederse desde ningún método.
F Una clase abstracta no puede tener métodos implementados.
F Una clase abstracta puede ser instanciada solo si no se producen llamados al método que no está definido.
V Una clase abstracta puede ser instanciada solo si no se producen llamados a la función miembro que no está definida.
V Una función estricta solo puede evaluarse si sus argumentos pueden evaluarse.
V Una función polimórfica es una única abstracción que opera de igual manera para una amplia gama de tipos de datos
F El tiempo de vida de una variable transcurre desde el momento en que su valor es utilizado por primera vez hasta que se deja de usarlo.
F La herencia múltiple se produce cuando una clase posee más de una clase descendiente.
F Si una clase posee más de una clase descendiente estamos en presencia de una herencia múltiple.
F La instanciación ocurre inmediatamente luego de definirse una clase.
V La sobrecarga puede utilizarse, en la jerarquía de clases, como un mecanismo para anular operaciones de niveles superiores
V La función function sum (x: int, y: int) = 1 + x + y; produce un mapeo Int x Int → Int
F La función function sum (x: int, y: int) = 1 + x + y; produce un mapeo Int x Int → Int + Int + Int
V En la declaración function swap (x, y: integer); ‘x’ e ‘y’ son denominados parámetros actuales.
F En la declaración function swap (x, y: integer); ‘x’ e ‘y’ son denominados parámetros actuales.
F En la declaración function intercambio (x, y: integer); ‘x’ e ‘y’ son denominados parámetros actuales.
V En la declaración function intercambio (x, y; integer); ‘x’ e ‘y’ son denominados parámetros formales.
F En la programación orientada a objetos, los datos están desorganizados, son meros apéndices de los programas.
V Las características públicas de una clase de denomina interfaz de la misma.
V La redefinición de un método puede utilizarse, en la jerarquía de clases, como un mecanismo para anular operaciones de niveles superiores.
F La definición de clases crea objetos implícitamente.
V Los métodos residen en los objetos y determinan como actúan los mismos cuando reciben un mensaje.
F Las clases que heredan características de una clase abstracta no pueden servir como base para definiciones de otras clases.
F Una coerción es un mapeo implícito entre valores de un mismo tipo.
En una relación de composición en POO, un objeto forma parte de otros objetos componentes.
Marque con una cruz la respuesta correcta.
1. Si T = A + B y T’ = A’ + B’, luego T  T’ si:
• A  A’ y B  B’
• A  B’ y B  A’ o A  B y B’  A’.
• A  A’ y B  B’ o A  B’ y B  A’.
2. Si T = A + B y T’ = A’ + B’, luego T  T’ (equivalentes) si:
• A  A’ y B  B’
• A  A’ y B  B’ o A  B’ y B  A’.
• A  B’ y B  A’.

1
 Geradem
3. La ocurrencia de enlace del identificador I es cuando…
• Se hace uso de I en el código de una función o procedimiento.
• I denota el valor que contiene.
• I aparece en la sección de definiciones de constantes o variables
4. Un tipo de datos primitivo…
• es aquel que está predefinido en algún lenguaje de programación.
• está compuesto por valores atómicos.
• es un conjunto de valores que cuyo comportamiento es simple y primitivo.
5. El producto cartesiano Integer x Char se define como:
• {(m, n) / m es un Char y n es un Integer}
• {m / m es un Integer}  {n / n es un Char}
• {(m, n) / n es un Char y m es un Integer}
6. Si T es un tipo de datos, la cardinalidad de un conjunto potencia de T es:
• #T2
• 2#T
• #T.2
7. La Herencia…
• … múltiple, se produce cuando una clase posee más de una clase descendiente.
• …soluciona elegantemente la necesidad de reutilización de código.
• … múltiple, no produce conflicto de nombres si en las clases inmediatamente superiores no existen atributos/métodos con
el mismo identificador.
• … múltiple, impide redefinir métodos en las subclases si existe conflicto de nombres.
• …simple supone una relación de generalización-especialización entre clases.
8. Cuando se realiza el paso de parámetros a una abstracción…
• …se puede utilizar un mecanismo de copia o referencia
• …el mecanismo de copia puede simular el mecanismo de referencia con parámetros de entrada/salida
• …el mecanismo de copia puede ser más lento que el mecanismo de referencias
• …un parámetro constante utiliza el mecanismo por referencias
9. La evaluación perezosa…
• …evalúa los parámetros actuales en la llamada a la abstracción, pero no los utiliza hasta que se necesario
• …evalúa los parámetros actuales dentro de la abstracción recién cuando se los necesite
• …evalúa los parámetros actuales dentro de la abstracción cada vez que aparezca el parámetro formal de su definición
• …evalúa los parámetros actuales cuando se llama a la abstracción siempre y cuando se determine que el parámetro formal
será utilizado
10. Suponga que el identificador “subs” esta sobrecargado (independiente del contexto) con el siguiente tipo string x int x
int -> string. Para mantener el tipo de sobrecarga se pueden agregar las siguientes abstracciones:
• String x int -> string; string -> char
• String x int -> char; string x int x int -> char
• String x int -> string; string x int -> char

2
 Geradem
11. Suponiendo la equivalencia de tipos por nombre, indicar que asignaciones del siguiente fragmento de código
(numeradas del 1 a 4) serian correctas y porque (para todos los casos)
Type (1): Da error de tipo □ – No da error de tipo □
Reg: RECORD Razón: Los campos c1 y c2 de x no poseen el mismo tipo de datos
c1: int
c2: char
END; (2): Da error de tipo □ – No da error de tipo □
VAR
Razón: “x” y “z” no fueron definidos en la misma declaración
x,y: reg;
z: RECORD
c1: int
c2: char (3): Da error de tipo □ – No da error de tipo □
END; Razón: “x” e “y” no fueron definidos en la misma declaración
i: integer;
Begin
... (4): Da error de tipo □ – No da error de tipo □
x.c2 := x.c1-1; (1) Razón: “z” e “y” no fueron definidos en la misma declaración
z.c2 := x.c2; (2)
x := y; (3)
z := y; (4)
12. Suponiendo la equivalencia de tipos por nombre, indicar qué asignaciones del siguiente fragmento de código
(numeradas del 1 a 4) serían correctas y por qué (para todos los casos).

VAR (1): Es correcta, los campos c1 y c2 del registro están definidos en la misma
x,y: RECORD declaración
c1:,c2: integer
END;
(2): Es correcta ya que “x” e “y” están definidas en la misma declaración por lo tanto
z: RECORD serian de un tipo de dato equivalente
c1:,c2: integer
END; (3): Es correcta ya que “x” e “y” están definidas en la misma declaración por lo tanto
i: integer; serian de un tipo de dato equivalente
Begin
...
x.c2 := x.c1+1; (1)
y.c1 := x.c1; (2) (4): Es incorrecta ya que “y” y “z” no serían de tipos de datos equivalentes ya que no
x := y; (3) están definidas en la misma declaración
z := y; (4)
END;
13. En un lenguaje con equivalencia por nombres se da lo siguiente:
type
persona = record
id: integer;
peso: real
end;
auto = record
id: integer;
peso: real
end;
var
x : persona;
y : auto;
¿Es válida la una asignación: x:=y?; Si o No explique en el reverse de la hoja.
No. Porque persona y auto no están definidos en el mismo lugar.
14. Y en otro lenguaje que tiene equivalencia estructural, son equivalentes los tipos IA y JA. Explique Formalmente.
IA : array [1..10] of Integer;
JA : array [1..10] of Integer;
Porque son dos tipos compuestos (mapeo). Por lo tanto, serán equivalentes estructuralmente si se da:
T = A → B y T’= A’ → B’; T  T’ si A  A’ y B  B’
15. Si T = A + B y T’ = A’ + B’, luego T  T’ si: A  A´ y B  B’ o A  B´ y B  A’
16. Si T = A x B y T’ = A’ x B’, luego T  T’ si: A  A´ y B  B’

3
 Geradem
17. Un valor es: todo aquello que puede ser evaluado, almacenado, incorporado a una estructura de datos, pasado como
argumento a procedimientos o funciones o devuelto como resultado de una función.
18. Un tipo es: un conjunto de valores que tienen un comportamiento uniforme ante operaciones relacionadas al tipo
19. Un tipo primitivo es aquel: cuyos valores son atómicos y no pueden descomponerse en valores más simples
20. Un tipo compuesto es aquel: cuyos valores están compuestos por valores más simples
21. El producto cartesiano se define formalmente como: A x B = { (x, y) / x  A; y  B }
22. El mapeo se define formalmente como: S → T = { m / x  S; m(x)  T }
23. El conjunto potencia se define formalmente como: S = {s / s  S}
24. Podemos definir enlace como: la asociación de un identificador a la entidad que va a denotar, un ejemplo sería:
25. El orden de evaluación de parámetros se refiere exactamente a: el momento en que se evalúan los parámetros formales
en la llamada a la abstracción.
26. Podemos definir ocurrencia de aplicación de un identificador como: la ocurrencia de un identificador cuando denota a la
entidad a la cual está asociada
27. Evaluar en Orden normal significa: que el parámetro actual no se evalúa en la llamada a la abstracción, sino que se
sustituye en cada ocurrencia de parámetro formal dentro de la abstracción
28. Evaluar en Orden impaciente significa: Evaluar el parámetro una vez y sustituir su valor en cada ocurrencia del parámetro
formal
29. Sobrecarga significa: que un número de abstracciones distintas están asociadas a un mismo identificador; pueden no tener
tipos relacionados ni hacer las mismas cosas sobre sus parámetros.
30. Polimorfismo es: una propiedad de una única abstracción que tiene varios tipos relacionados y opera uniformemente
sobre ellos.
31. Una expresión es: una frase de programa que será evaluada para retornar un valor y un comando es: una frase de
programa que será ejecutada para actualizar variables.
32. Haga un cuadro con las ventajas y desventajas de cada una de las formas de evaluar los parámetros que conoce.
Ev. Impaciente Ev. Orden Normal Ev. Perezosa
Evalúa el parámetro en la Evalúa el parámetro en el cuerpo de la Evalúa el parámetro en el cuerpo de la abstracción.
llamada abstracción cuando hace falta
Desventaja, evalúa el Ventaja, evalúa el parámetro solo Ventaja, evalúa el parámetro cuando hace falta. si
parámetro, aunque no se use. cuando se usa. no se usa no se evalúa.
Ventaja, evalúa una sola vez un Desventaja, puede evaluar muchas Ventaja, evalúa una sola vez y si lo guarda para
parámetro. veces un mismo parámetro usarlo otra vez.
Desventaja, puede ocupar mucha memoria para
guardar todos los parámetros evaluados.
33. Realice una comparación entre el mecanismo de paso de parámetros por copia y por referencia. (en el reverso de la hoja)

34. Para el mecanismo de paso de parámetros por copia, enumere cuál es el efecto de entrada y de salida para los
parámetros valor, resultado y valor/resultado. (en el reverso de la hoja)
X: Parámetro formal.
Ef. Entrada: Ef. Salida
Valor X:= argumento -
Resultado - argumento := X
Valor/Resultado X:= argumento argumento := X

4
 Geradem
35. Establezca en un cuadro comparativo, las diferencias que existen entre una variable de clase y una de instancia. (en el
reverso de la hoja)

36. A qué se refiere el término Modularidad. Explique 3 características básicas que debe tener un módulo. (en el reverso de
la hoja)

37. Qué entiende por control de tipos: es la acción que realizan las implementaciones de los leguajes para controlar que los
tipos de los operandos con los cuales sean compatibles con la operación que se está realizando
Caracterice el control dinámico:
o Solo los valores tienen un tipo fijo.
o Una variable o parámetros no tienen un tipo designado
o Una variable o parámetros puede tomar valores de diferente tipo en diferentes momentos.
o El tipo de los operandos deben ser chequeados inmediatamente antes de realizar una operación en tiempo de
ejecución.
Caracterice el control estático:
o Cada variable y parámetro tiene un tipo fijo y es elegido por el programador.
o El tipo de cada expresión puede ser deducido y la comprobación de tipo se realiza en tiempo de compilación.
o La mayoría de los lenguajes de alto nivel son estáticamente tipeados.
38. El orden de evaluación de parámetros se refiere exactamente a: al momento en que cada parámetro actual se evalúa
cuando se llama a una abstracción
Evaluar en Orden impaciente significa: que se evalúa el parámetro actual una sola vez, y en efecto se sustituye el resultado
en cada ocurrencia del parámetro formal.
Evaluar en Orden normal significa: No se evalúa inmediatamente el parámetro actual, sino que se sustituye el parámetro
actual por cada ocurrencia del parámetro formal.
39. Enumere los valores del mapeo binario; binario = array [1..3] of [0..1] (en el reverso de la hoja)
{ {1 → 0, 2 → 0, 3 → 0} {1 → 0, 2 → 1, 3 → 1} {1 → 1, 2 → 1, 3 → 0}
{1 → 0, 2 → 0, 3 → 1} {1 → 1, 2 → 0, 3 → 0} {1 → 1, 2 → 1, 3 → 1}
{1 → 0, 2 → 1, 3 → 0} {1 → 1, 2 → 0, 3 → 1} }
40. Enumere los valores del mapeo; arreglo; arreglo = array [‘a’..‘c’] of 0..1 (en el reverso de la hoja)
{ {a → 0, b → 0, c → 0} {a → 0, b → 1, c → 1} {a → 1, b → 1, c → 0}
{a → 0, b → 0, c → 1} {a → 1, b → 0, c → 0} {a → 1, b → 1, c → 1}
{a → 0, b → 1, c → 0} {a → 1, b → 0, c → 1} }
41. Enumere los valores del mapeo arreglo; arreglo = array [‘x’..‘z’] of 1..2 (en el reverso de la hoja)
{ {x → 1, y → 1, z → 1} {x → 1, y → 2, z → 2} {x → 2, y → 2, z → 1}
{x → 1, y → 1, z → 2} {x → 2, y → 1, z → 1} {x → 2, y → 2, z → 2}
{x → 1, y → 2, z → 1} {x → 2, y → 1, z → 2} }
42. Cuál es el mapeo que produce la siguiente función en un lenguaje hipotético:
fun cociente (m, n: integer): real;
{
return (m / n);
}
Enumere algunos de sus valores.

5
 Geradem
43. Cuál es el mapeo que produce la siguiente función:
function mayor (m, n: integer): bolean;
begin
mayor := m>n;
end;
Enumere sus valores.

44. Para el mecanismo de paso de parámetros por copia, enumere cuales son los posibles argumentos que se deben pasar para el
parámetro valor, resultado y valor-resultado. (en el reverso de la hoja)
Parámetros valor: Valor de 1era clase
Parámetro Resultado: Variable
Parámetro Valor/Resultado: Variable
45. Enumere los valores del conjunto potencia ConjTri; (en el reverso de la hoja)
triang = (equilatero, escaleno, isosceles);
ConjTri = set of triang;
{ {} {equilatero} {escaleno} {isosceles} {equilatero, escaleno}
{equilatero, isosceles} {escaleno, isosceles} {equilatero, escaleno, isosceles} }
46. Enumere los valores del conjunto potencia estilo;
formato = (negrita, subrayado, cursiva);
estilo = set of formato;
{ {} {negrita} {subrayado} {cursiva} {negrita, subrayado} {negrita, cursiva}
{subrayado, cursiva} {negrita, subrayado, cursiva} }
47. Muestre el conjunto de valores de cada tipo Pascal usando la notación de producto cartesiano, uniones disjuntas y
mapeo.
Palo = (espada, oro, copa, basto); turno = record case pase: boolean of
Num = 1..10; false : (jugada: carta);
Carta = record p: palo, n: num end; true : ()
Mano = array [1..3] of carta; end;

Carta = palo x num

Mano = [1..3] → (palo x num)
Turno = () + (palo x num)
48. Cuál es la cardinalidad de cada uno de los siguientes tipos.
Palo = (espada, oro, copa, basto); turno = record case pase: boolean of
Num = 1..10; false : (jugada: carta);
Carta = record p: palo, n: num end; true : ()
Mano = array [1..3] of carta; end;
# palo = 4# mano = #carta #[1..3] = 64.000
# num = 10 # turno = # () + # carta = 41
# carta = # palo x # num = 40
49. Considere el siguiente procedimiento Pascal:

Procedure multiplicar (var m, n: integer); Suponga que i contiene 2 y j contiene 3. Muestre que se
Begin escribe durante las siguientes llamadas por referencia:
m:= m*n; writeln (m, n); a) Multiplicar (i, j);
end;
b) Multiplicar (i, i);
Suponga que los parámetros por referencias se reemplazan
por parámetros valor-resultado. Repita el ejercicio.
Parámetros por referencia a) 6, 3 b) 4, 4
Parámetros valor-resultado a) 6, 3 b) 4, 2

6
 Geradem
50. Considere el siguiente procedimiento Pascal:

procedure calcular (var m, n: integer); Suponga que i contiene 3 y j contiene 2. Muestre que se
begin escribe durante las siguientes llamadas por referencia:
m:= 2*m*n; writeln (m, n); a) Calcular (i, j);
end;
b) Calcular (i, i);
Suponga que los parámetros por referencias se reemplazan
por parámetros valor-resultado. Repita el ejercicio.
Parámetros por referencia a) 12, 2 b) 18, 18
Parámetros valor-resultado a) 12, 2 b) 18, 2
51. Considere el siguiente procedimiento Pascal:

Procedure multiplicar (var m, n: integer); Suponga que i contiene 3 y j contiene 4. Muestre que escribe
Begin el procedimiento durante las siguientes llamadas por
m:= m*n; write (m, n); referencia:
end; c) Multiplicar (i, j);
d) Multiplicar (i, i);
Suponga que los parámetros por referencias se reemplazan
por parámetros valor-resultado. Repita el ejercicio.
Parámetros por referencia a) 12 - 4........................................... b) 9 - 9 ...............................................
Parámetros valor-resultado a) 12 - 4........................................... b) 9 - 3 ...............................................
52. Considere el siguiente procedimiento Pascal:

procedure calcular (var m, n: integer); Suponga que i contiene 2 y j contiene 3. Muestre que escribe
begin el procedimiento durante las siguientes llamadas por
m:= 2*m*n; write (m, n); referencia:
end; c) Calcular (i, j);
d) Calcular (i, i);
Parámetros por referencia a) 12 - 3........................................... b) 8 - 8 ...............................................
Parámetros valor-resultado a) 12 - 3........................................... b) 8 - 2 ...............................................
53. Considere el siguente procedimiento Pascal:
Procedure multiplicar (var m, n: integer); Suponga que i contiene 3 y j contiene 2. Muestre que escribe
Begin el procedimiento durante las siguientes llamadas por
m:= m*n; write (m, n); referencia:
end; e) Multiplicar (i, j);
f) Multiplicar (i, i);
Suponga que los parámetros por referencias se reemplazan
por parámetros valor-resultado. Repita el ejercicio.
Parámetros por referencia a) 6, 3 b) 4, 4
Parámetros valor-resultado a) 6, 3 b) 4, 2
54. Suponga que el operador “&” (que denota concatenación) está sobrecargado con los tipos:
Character x character → string character x string → string
String x character → string string x string → string
¿Es una sobrecarga dependiente o independiente del contexto?: independiente del contexto
¿Por qué?: con el tipo de los operandos es suficiente para determinar cuál es la abstracción que se va a denotar
55. Suponga que el operador “/” (que denota cociente) está sobrecargado con los tipos:
int x int → int float x float → float
int x int → float
¿Es una sobrecarga dependiente o independiente del contexto?: dependiente del contexto
¿Por qué?: con solo el tipo de los operadores no es suficiente para determinar cuál es la abstracción que se va a denotar. Es
necesarios saber cuál es el contexto donde se encuentra la expresión

7
 Geradem
56. Suponga que el operador “&” (que denota concatenación) está sobrecargado con los tipos:
&:: char x char → string (1) char x string → string (3) Tipo de Sobrecarga: Independiente del contexto
string x char → string (2) string x string → string (4)
Y que la función f está sobrecargada con los tipos:
f :: string → string (5) Tipo de Sobrecarga: Dependiente del contexto
string → int (6)
En cada caso determine el tipo de sobrecarga. Por qué?:
En &:: el programa dará un tipo de resultado según el tipo de entrada que reciba, sin embargo en f :: el programa no tendrá como
diferenciar los tipos de datos de entrada para luego dar diferentes tipos de salidas entonces será el contexto el que defina los tipos
de datos de salida
En la llamada f (‘cad’&‘ena’) < 0 cuáles serán las abstracciones que se invocarán y por qué?
Primero se invocará a la abstracción 4 ya que los tipos de datos de entrada serian 2 string, produciendo como resultado un string,
luego en la función f se invocará a la abstracción 6 ya que según el contexto es necesario un entero para luego evaluar si es menor a
0 (cero)
57. Diga si en las siguientes llamadas a la función “mul” producirán algún error de tipos en un lenguaje hipotético
dinámicamente tipeado. En los casos afirmativos diga en qué momento.
fun mul (n) = result (n mod 5 = 0);
x:= ‘a’; n:= 3; m:= 5.1521;
mul (x+1); Si No Al intentar sumar x + 1
mul (true); Si No Al intentar dividir n mod 5; n es un valor lógico
mul (n); Si No
mul Si No Al intentar dividir n mod 5; n es un flotante
(m+3.5);
58. Diga si en las siguientes llamadas a la función “div” producirán error de tipos en un lenguaje hipotético estáticamente
tipeado. En los casos afirmativos diga en qué momento.
function div (m, n: integer; var r: integer): integer;
begin r := m div n; end;
x: char; y, p, q: integer; z: real;
div (x+1, y, z); Si No al querer sumar x+1 porque x es un char
div (y, 2, z); Si No z es un real y se espera un parámetro entero
div (y+1, y+2, y); Si No
div (p, q, 5); Si No 5 es una constante, debe ser una variable
59. Cuál es el entorno de cada punto numerado en el siguiente programa pascal.
program p;
const x = 999;
(1) type nat = 0..x;
(2) var m, n : nat;
(3) function f (n : nat) : nat;
const m = 6;
begin
(4) ...
end;
begin
(5) ...
end;
60. Describa el mecanismo de paso de parámetros por definición.
Este mecanismo permite que el parámetro formal X se enlace directamente al argumento. Esto da una semántica simple y
uniforme para el paso de parámetros de cualquier valor en el lenguaje de programación (no solo los valores de primera clase).
En el caso de un parámetro constante, el argumento es un valor (de primera clase). X se enlaza al valor del argumento durante
la activación de la llamada a la abstracción.
En el caso de un parámetro variable (o por referencia), el argumento es una referencia a una variable. X se enlaza a la variable
argumento durante la activación de la llamada a la abstracción. Por lo tanto, cualquier actualización o inspección de X es
realmente una actualización o inspección del argumento.

8
 Geradem
En el caso de un parámetro procedural, el argumento es una abstracción de procedimiento. X se enlaza al procedimiento
(argumento) durante la activación de la llamada a la abstracción. Por lo tanto, cualquier llamada a X es realmente una llamada al
procedimiento (argumento).
En el caso se un parámetro funcional, el argumento es una abstracción de función. X se enlaza a la función (argumento)
durante la activación de la llamada a la abstracción. Por lo tanto, cualquier llamada a X es realmente una llamada a la función
(argumento).
Es importante observar que estos no son mecanismos distintos. En cada caso, el efecto es como si el cuerpo de la abstracción
esté rodeado por un bloque en el cual hay una definición que enlaza X al argumento — de ahí, nuestra terminología de
mecanismo por definición.
61. Describa el mecanismo de paso de parámetros por copia.
Un mecanismo de copia permite que valores se copien a y/o desde una abstracción cuando se la llama. El parámetro formal X
denota una variable local para la abstracción. Un valor se copia en X a la entrada de la abstracción, y/o se copia de X (a una
variable no local) a la salida de la abstracción. Debido a que X es una variable local, se crea a la entrada de la abstracción y se
elimina a la salida.
Un parámetro por valor es una variable local X que se crea a la entrada de la abstracción y se le asigna el valor del argumento.
Debido a que X se comporta como una variable local, su valor puede ser inspeccionado y actualizado. Sin embargo, cualquier
actualización de X no tiene efecto en ninguna variable no local.
Un parámetro resultado es todo lo contrario del anterior. En este caso, el argumento debe ser una referencia a una variable. De
nuevo una variable local X se crea, pero su valor inicial es indefinido. A la salida de la abstracción el valor final de X es asignado a
la variable argumento.
Estos dos mecanismos pueden ser combinados para dar resultado a los parámetros valor resultado. El argumento, de nuevo,
debe ser una referencia a variable. En la entrada de la abstracción, la variable local X se crea y se le asigna el valor actual de la
variable argumento. A la salida, el valor final de X se asigna nuevamente a la variable argumento.
62. Qué es un sistema de tipos monomórfico.
Cada constante, variable, resultado de función y parámetro formal, deben declararse con un tipo específico. Este sistema de
tipos se denomina monomórfico

63. Que entiende por lenguaje tipeado estáticamente o dinámicamente.

En un lenguaje tipeado estáticamente, cada variable y parámetro tiene un tipo fijo y es elegido por el programador. Por lo tanto,
el tipo de cada expresión puede ser deducido y la comprobación de tipo se realiza en tiempo de compilación. La mayoría de los
lenguajes de alto nivel son estáticamente tipeados.
En un lenguaje tipeado dinámicamente, solo los valores tienen un tipo fijo. Una variable o parámetros no tienen un tipo
designado, pero pueden tomar valores de diferente tipo en diferentes momentos. Esto implica que el tipo de los operandos
deben ser chequeados inmediatamente antes de realizar una operación en tiempo de ejecución. Lisp y Smalltalk son lenguajes
dinámicamente tipeados.