Lenguajes de Programación Tema 2. Semántica básica

Presentación del tema: "Lenguajes de Programación Tema 2. Semántica básica"— Transcripción de la presentación:

1 Lenguajes de Programación Tema 2. Semántica básica
Pedro García López

2 Copyright © University Rovira i Virgili
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; provided its original author is mentioned and the link to is kept at the bottom of every non-title slide. A copy of the license is available at:

3 Indice 2.1 Introducción 2.2 Valores y variables 2.3 Tipos de datos
2.4 Abstracciones 2.5 Encapsulación

4 2.1 Introducción Variables y asignación -- Storage fetch & update
Estructuras de datos Storage structs Estructuras de control Saltos (JUMPS) Procedimientos Subrutinas Genericidad Reutilización Bloques, modulos Encapsulación Abstraccion

5 2.2 Valores y variables Las variables, los procedimientos o las constantes tienen nombres asignados por el programador Los valores son cualquier entidad almacenable como enteros, reales o arreglos. Las localizaciones son lugares o zonas de memoria donde se almacenan estos valores. El significado de un nombre queda determinado por las propiedades o atributos asociados con el mismo

6 Atributos const int n = 5 Ejemplo: Esta declaración convierte a n en una constante entera con valor 5, es decir, asocia al nombre n el atributo de tipo de datos contante entera y el atributo de valor 5

7 Atributos El proceso de asociación de un atributo a un nombre se conoce como ligadura (binding). Dependiendo del momento de asociación la ligadura puede ser estática (tiempo de compilación) o dinámica (tiempo de ejecución). y = new int; int n = 5; a = ‘pedro’ a = 3

8 Tabla de símbolos © 2003 Brooks/Cole - Thomson Learning™ © 2003 Brooks/Cole - Thomson Learning™ La tabla de símbolos (symbol table) almacena las ligaduras de atributos a nombres El entorno (environment) almacena las ligaduras de nombres a localizaciones de memoria.

9 Declaraciones, bloques y alcance
La declaración es el método esencial para establecer ligaduras. Las declaraciones están asociadas comúnmente con constructores del lenguaje como los bloques. Las declaraciones pueden tambien asociarse a estructuras de datos como registros, o en agrupaciones más amplias como paquetes, módulos y namespaces.

10 Ámbito X Y Z

11 Ámbito Alcance estático o dinámico en la tabla de símbolos. const s=2;
function scaled (d: Integer); begin scaled:= d*s; end; procedure q; const s = 3; begin (2) ... scaled(h) ... end begin (1) ... scaled(h) ... end;

12 Variables y asignación
Una variable es un objeto cuyo valor almacenado puede cambiar durante la ejecución. x = y © 2003 Brooks/Cole - Thomson Learning™

13 Variables y asignación
Asignación por copia o clonación (semántica de almacenamiento), por referencia o compartición (semántica de apuntador). Un alias ocurre cuando el mismo objeto está vinculado a dos nombres diferentes al mismo tiempo. Los alias pueden presentar efectos colaterales. © 2003 Brooks/Cole - Thomson Learning™

14 Variables y asignación
Referencias perdidas free y malloc Basura, memoria asignada en el entorno que se ha convertido en inaccesible para el programa. El recolector de basura: Garbage collector

15 2.3 Tipos de datos Un tipo de datos es un conjunto de valores, junto con un conjunto de operaciones sobre dichos valores y con ciertas propiedades. Lenguajes fuertemente tipados (tipado estático) frente a lenguajes debilmente tipados (tipado dinámico) La verificación de tipos es el proceso que comprueba la consistencia del uso de tipos de un programa

16 Tipado estático (ventajas)
Mejora la eficiencia de la ejecución Mejora la eficiencia de traducción Mejora la capacidad de escritura y la detección de errores Mejora la seguridad y confiabilidad Mejora la legibilidad Elimina ambigüedades La verificación de tipos estáticos es una herramienta de diseño Mejora la consistencia y corrección de la interfaz

17 Preguntas En grupos de 2 a 3 personas contestad a las siguientes cuestiones: Justificad y explicad cada uno de los puntos de la transparencia anterior. Justificad el uso del tipado dinámico con ejemplos

18 Clasificación de tipos
Tipos primitivos (integer, boolean, char) Producto cartesiano (record, struct) Unión disjunta (union) Mapping (array, function) Set Enumerados Tipos recursivos y apuntadores Strings Tipos compuestos

19 Tipos en C © 2003 Brooks/Cole - Thomson Learning™

20 Tipos en Java © 2003 Brooks/Cole - Thomson Learning™

21 Tipos en Ada © 2003 Brooks/Cole - Thomson Learning™

22 Monomorfismo y polimorfismo
Monomorfismo: Cada constante, variable, resultado de función o parámetro formal debe ser declarado de un tipo concreto. Ventajas: simplicidad, chequeo estático de tipos. Inconvenientes: Va contra la reusabilidad del código. Es poco flexible. Va contra el código genérico. Polimorfismo: Cuando una abstracción opera de forma uniforme sobre valores de diferentes tipos. Ventajas: potencia, elegancia, flexibilidad, reusabilidad, código generico. Inconvenientes: eficiencia, chequeo dinámico.

23 Sistemas de Tipos Sobrecarga (overloading): la capacidad de que un operador o identificador denote distintas abstracciones simultáneamente. Ej: write. Ventajas: simplicidad, polimorfismo aparente. Inconvenientes: Duplicidad de código, poco elegante para determinados problemas. Herencia y sistemas de tipos(inheritance): referente a los tipos, subtipos, supertipos y en particular la capacidad de los subtipos de heredar operaciones de sus supertipos. Dualidad Modulo-tipo

24 Sistemas de Tipos Monomorfismo Ej: PASCAL type CharSet = set of Char;
function disjoint (s1,s2:CharSet):Boolean; begin disjoint := (s1*s2 = []) end var chars: CharSet; ... if disjoint (chars, [‘a’,’e’,’i’,’o’,’u’]) then ... ¿ Puede usarse disjoint sobre Integer o Color ?

25 Sistemas de Tipos Sobrecarga
Ej: PASCAL Operadores: +,-, *. write(int), write (String), write (Character) File of Integer, File of Character, File of X eof(f) generico !!! PASCAL es inconsistente: las abstracciones definidas por el usuario solo pueden ser monomorficas mientras para solucionar problemas de genericidad utiliza la sobrecarga.

26 Sistemas de Tipos Sobrecarga (tipos)
Dadas f1: S1 -> T1 y f2: S2 -> T2 Sobrecarga independiente del contexto (Pascal y ML). Requiere que S1 y S2 sean diferentes Sobrecarga dependiente del contexto(Ada). Requiere que S1 sea distinto de S2 o bien que T1 sea distinto de T2. function “/”( m,n: Integer) return Float is begin return Float(m)/ Float(n); end;

27 Sistemas de Tipos Polimorfismo (paramétrico)
function second(x:a, y:b) = y; - second (13,true): Politipo: a x b -> b donde a y b son tipos. Ejemplos:Integer x Boolean -> Boolean y String x String -> String. Ej. PASCAL function disjoint (s1,s2:set of a):Boolean; begin disjoint := (s1*s2 = []) end

28 Sistemas de Tipos Polimorfismo (paramétrico). ML. Ejemplos:
- fun id (x: a) = x; datatype a list = nil |cons of (a* a list) fun hd (l: a list) = ... fun tl ( l: a list) = ... fun length (l: a list) = Case l of Nil => 0 | cons (h,t) => 1 + length (t)

29 Sistemas de tipos Polimorfismo paramétrico: Generics en Ada
Templates en C++ Ejemplos: Pila<T>, maximo(x:T, y:T) Polimorfismo paramétrico restringido Ejemplo. Pila<Persona>

30 Sistemas de Tipos Inferencia de tipos
Monomórfica: fun even (n) = (n mod 2 = 0); Infiere un entero Polimórfica: fun id(x) = x Infiere un politipo. Casting (coercions): Conversion forzosa entre tipos distintos.

31 Sistemas de Tipos Polimorfismo de inclusión (Herencia)
Tipos y subtipos Asignación polimórfica Ligadura dinámica Conclusiones: Polimorfismo está íntimamente relacionado con el código generico, reutilización y extensibilidad.

32 Preguntas En grupos de 2 a 3 personas contestad a las siguientes cuestiones: ¿ Qué tipos de polimorfismo soporta Ada ? ¿ Qué tipos de polimorfismo soporta C ? ¿ Qué tipos de polimorfismo soporta Java ? Añadid para cada tipo de polimorfismo en cada lenguaje al menos una línea de código que lo demuestre.

33 2.4 Abstracciones Secuenciadores Saltos Escapes Excepciones

34 Abstracciones Clases Funcional Procedural Parámetros
Mecanismos de copia Mecanismos de referencia Principio de correspondencia

35 Abstracciones Clases (procedural y funcional) Parametrización
Binding y parametrización Descomposición de problemas Abstracciones Caja negra

36 Abstracciones Abstracciones funcionales
function power (x:Real; n:Integer):Real; begin if n = 1 then power := x else power:= x * power ( x , n-1) end

37 Abstracciones Abstracciones funcionales fun power (x:real; n:integer)=
if n = 1 then x else x * power ( x , n-1) end Vista del implementador Vista Usuario

38 Abstracciones Abstracciones procedurales
type WordSequence = array [...] of Word; procedure sort (var words : WordSequence); Vista del implementador Vista Usuario Asignación Algoritmo Abstracciones funcionales Expresiones Abstracciones procedurales Comandos

39 Abstracciones Parámetros Parámetro formal Parámetro actual Argumento
Copia Referencia (Definitional) Paso de parámetros

40 Abstracciones Mecanismos de copia Valor Resultado Valor-resultado
Mecanismo Entrada Salida Valor X:=argumento - Resultado - argumento:= X Valor-resultado X:=argumento argumento:=X

41 Abstracciones Principio de correspondencia: Para cada tipo de declaración existe un correspondiente paso de parámetros y vice versa. Declaración Parámetro formal Parámetro actual const I=E const I :T expression E of type T var I:= E I : T expression E of type T var I = V var I : T variable access Vof type T

42 Abstracciones Ordén de Evaluación Eager evaluation
Normal-order evaluation Lazy evaluation Ejemplos: a) fun sqr (n:int) = n* n b) sqr(getint(f))

43 2.5 Encapsulación Tipos abstractos de datos (TADs) Paquetes y módulos
Ocultación de Información Objetos y clases Genericidad Abstracciones genéricas Type parameters

44 Tipos de datos definidos por el usuario
Los lenguajes deben ofrecer un mecanismo para construir tipos que disponga de : Un método para definir un tipo de datos y a la vez las operaciones sobre dicho tipo.Las operaciones deben quedar asociadas directamente con el tipo. Las definiciones no deben depender de detalles de implementación Un método para reunir en un solo lugar los detalles de implementación del tipo y sus operaciones, así como restringir el acceso a dichos detalles a los programas que utilizan el tipo de datos.

45 Tipos abstractos de datos
Encapsulación: recolección en una sola localización de todas las definiciones relacionadas con el tipo de datos, restringiendo el uso del tipo a las operaciones definidas en dicha localización. Ocultación de información: separación de los detalles de implementación de las definiciones, y posibilidad de restringir el acceso a determinados detalles de la implementación.

46 Semántica Algebraica Especificación de un tipo abstracto
Teoría denotada por la especificación Algebra que satisface la teoría La especificación algebraica consiste de dos partes: la signatura y los axiomas. La signatura define los tipos, operaciones y funcionalidad. Los axiomas son sentencias lógicas que describen el comportamiento de las operaciones

47 Semántica Algebraica specification TRUTH-VALUES sort Truth-Value
operations true : Truth-Value false : Truth-Value not_ : Truth-Value -> Truth-Value _^_ : Truth-Value,Truth-Value -> Truth- Value _v_ : Truth-Value,Truth-Value -> Truth-Value _=>_ : Truth-Value,Truth-Value -> Truth-Value

48 Semántica Algebraica variables t,u:Truth-Value equations
not true = false not false = true t ^ true = t t ^false = false t ^ u = u ^ t t v true = true t v false = false t v u = u v t t => u = (not t) v u end specification

49 Semántica Algebraica specification LISTS include NATURALS
formal sort Component sort List operations empty-list : List cons (_,_) : Component , List -> List head _ : List -> Component tail _ : List -> List length _ : List -> Natural

50 Semántica Algebraica variables c:Component l: List equations
head cons (c,l) = c tail cons(c,l) = l tail empt-list = 0 length empty-list = 0 length cons(c,l) = succ(length l) end specification

51 TADs Tipos abstractos de datos (ML)
abstype rational = rat of (int * int) with val zero = rat(0,1); val one = rat (1,1); fun op // (m:int, n:int) = ... and op ++(rat(m1,n1):rational, rat(m2,n2):rational) = rat(m1*n2 + m2*n1, n1*n2) and op == ( ...) end

52 Módulos Un módulo es una unidad de programación con una interfaz pública y una implementación privada; todos los servicios disponibles de un módulo quedan descritos en su interfaz pública y se exportan a otros módulos, así como todos los servicios requeridos por un módulo deben importarse de otros módulos. © 2003 Brooks/Cole - Thomson Learning™

53 Compilación por separado en C y C++
C no tiene mecanismos modulares pero si tiene características de compilación por separado y de control de nombres para imitar módulos. © 2003 Brooks/Cole - Thomson Learning™

54 C y módulos Las directivas include proveen algo de documentación con respecto a las dependencias, pero esta información no puede ser utilizada por el compilador o enlazador. Todos los sistemas en C requieren que el usuario lleve un control del código fuente obsoletoy proceder manualmente a recompilar y volver a enlazar. (make) C++ tiene el mismo problema debido a una decisión de diseño (Stroustup) de compatibilidad con C.

55 Espacios de nombres Namespace en C++ y package en Java
Permite la introducción explícita de un alcance nombrado a fin de evitar choques de nombres entre bibliotecas compiladas por separado. package myqueue; import myqueue.Queue; Myqueue.Queue

56 Paquetes Abstracción -> Encapsulación -> Modularidad
Librerias de rutinas (c) -> Modulos (Modula 2) -> paquetes (Ada) -> clases (Smalltalk) Modularidad, TAD (tipos abstracto de datos), ocultación de información. Paquetes package I is D end I; structure I = struct D end

57 Paquetes Ocultación de información Ada: package body trig is ...
package trig is function sin(x:Float) return Float; function cos(x:Float) return Float; end trig; package body trig is ... end trig Favorece la programación por contrato (caja negra) Favorece la separación de interfaz de implementación independizando ésta.

58 Paquetes Clases y objetos (Ada) package directory_object is
procedure insert ( newname: in Name; newnumber: in Number); procedure lookup ( oldname: in Name; oldnumber: out Number, found: out Number); end directory_object; directory_object.insert(me, 6041); ... directory_object.lookup(me, mynumber,ok);

59 Paquetes Clases y objetos (Ada) generic package directory_class is
procedure insert ( newname: in Name; newnumber: in Number); procedure lookup ( oldname: in Name; oldnumber: out Number, found: out Number); end directory_object; package homedir is new directory_class; package workdir is new directory_class; workdir.insert(me,6050); homedir.insert(me,2323);

60 OOP Clases y objetos (Java OOP) class Directory { ... }
Directory homedir = new Directory(); Directory workdir = new Directory(); homedir.insert(2323); Workdir.insert(1212);

61 Genericidad Genericidad: polimorfismo paramétrico generic
capacity: in Positive; package queue_class is .... end queue_class; package body queue_class is items: array (1.. Capacity) of Character; package line_buffer is new queue_class (120);

62 Genericidad Genericidad (tipos) generic capacity: in Positive;
type Item is private; package queue_class is procedure append (newitem: in Item); procedure remove (olditem: out Item; end queue_class; package line_buffer is new queue_class (120, Character); line_buffer.append(‘*’);

63 Problemas de los TADs Los módulos no son tipos.
Los módulos son entidades estáticas. procedure Quser is package IntQueues is new Queues(Integer); use IntQueues; package FloatQueues is new Queues(Float); use FloatQueues; fq: FloatQueues.Queue; iq: IntQueues.Queue; begin fq := enqueue(fq,3.1); iq := enqueue(iq,3);

64 Problemas en los TAD Problemas de inicialización, asignación, igualdad, copia y control de memoria. Problemas de contrato y parametrización restringida (with en Ada). Las definiciones de los módulos no incluyen especificación de la semántica de las operaciones incluidas. La especificación algebraica incluye ecuaciones que explican la semántica. Eiffel resuelve esto mediante precondiciones, postcondiciones e invariantes.

65 Preguntas En grupos de 2 a 3 personas contestad a las siguientes cuestiones: De los problemas anteriores, ¿ cuales resuelve Java (explicad como) y cuales no ? ¿ Soporta Java encapsulación y ocultación de información ? ¿ como ? ¿ Soporta Java la compilación separada ? ¿ Gestiona Java automáticamente las dependencias entre módulos (clases) ? Ejemplo: detección de imports no usados, recompilación automática de dependencias al modificar una clase.