Tema 2. Abstracciones y Especificaciones.

1. Tema 2. Abstracciones y Especificaciones. 2.1. Introducción. 2.2. Especificaciones informales. 2.2.1. Abstracciones funcionales. 2.2.2. Abstracciones de datos. 2.2.3. Abstracciones de iteradores. 2.3. Especificaciones formales. 2.3.1. Método axiomático (o algebraico). 2.3.2. Método constructivo (u operacional). A.E.D. 1 Tema 2. Abstracciones y especificaciones.

2. 2.1. Introducción: Abstracción Abstraer: Eliminar lo irrelevante y quedarnos con lo realmente importante. ¿Qué es lo importante? En cada parte del trabajo puede serlo cosas distintas Para llevar a cabo la abstracción los lenguajes nos proporcionan mecanismos: Módulos, clases, genericidad, ocultación, encapsulación, ... A.E.D. 2 Tema 2. Abstracciones y especificaciones.

3. 2.1. Introducción: Diseño mediante abstracciones El diseño de programas está basado en el uso de abstracciones. Se trata de: 1. Identificar los subproblemas. 2. Especificación abstracta de cada uno de ellos. 3. Implementar cada abstracción. 4. Verificación del programa. A.E.D. 3 Tema 2. Abstracciones y especificaciones.

4. 2.1. Introducción: Mecanismos de abstracción Abstracción por especificación: Sólo necesitamos conocer qué va a hacer el procedimiento y no cómo funciona. (Encapsulación) Abstracción por parametrización: Un algoritmo, un tipo, o una variable se definen en base a unos parámetros. (Genericidad) A.E.D. 4 Tema 2. Abstracciones y especificaciones.

5. 2.1. Introducción: Tipos de abstracciones • Abstracciones funcionales  Rutinas, procedimientos. • La especificación determina los parámetros de entrada y salida y el efecto de la ejecución, pero no dice nada de la implementación. • Abstracciones de datos  Tipos Abstractos de Datos. • La especificación determina el comportamiento de las operaciones definidas, pero no dice nada del almacenamiento de los valores ni de la implementación de las operaciones. • Las estructuras de datos se usan para almacenar valores de un tipo, y constituyen la concretización de un tipo abstracto. • Un tipo de datos parametrizado incluye un parámetro que indica el tipo de los objetos almacenados (Lista[T:tipo] puede dar lugar a Lista[Natural] o Lista[Lista[Natural]] según T sea Natural o Lista[Natural]) • Abstracciones de iteradores  Iteradores. • Permite realizar un recorrido sobre los elementos de una colección. A.E.D. 5 Tema 2. Abstracciones y especificaciones.

6. 2.1. Introducción: Mecanismos de abstracción Evolución de los lenguajes de programación marcada por la necesidad de incluir nuevos mecanismos de abstracción. • Lenguajes primitivos: conjunto predefinido de tipos y posibilidad de crear otros nuevos. Engorroso. • Tipos definidos por el usuario: agrupar variables bajo el nombre del tipo. No se oculta la implementación. • Módulos: permiten encapsulamiento al agrupar bajo un mismo nombre tipos y las operaciones. • Clases y objetos. La clase es el tipo definido por el usuario y el módulo donde se encapsulan los datos y operaciones sobre el tipo. Los objetos son instancias de una clase. A.E.D. 6 Tema 2. Abstracciones y especificaciones.

7. 2.2. Especificaciones informales. La descripción de una abstracción se realiza con un lenguaje natural (ambiguas e imprecisas). Notación de espeficicación: Partes que debe tener la especificación, Significado y tipo de cada parte, Partes que pueden ser opcionales, ... A.E.D. 7 Tema 2. Abstracciones y especificaciones.

8. 2.2. Especificaciones informales: Abstracciones funcionales Notación Operación <nombre> (ent <id>: <tipo>;...; sal <tipores>) Requiere: establece restricciones de uso. Modifica: identifica los datos de entrada que se modifican. Calcula: descripción textual del resultado de la operación. Requiere y Modifica, y los parámetros de entrada y salida son opcionales. Puede ser parametrizada: Operación <nombre> [<id>:<tipo>;...] (... A.E.D. 8 Tema 2. Abstracciones y especificaciones.

9. 2.2. Especificaciones informales: Abstracciones funcionales Ejemplo 1: eliminar la repetición en los elementos de un array. Operación quitarduplic (ent a: array [entero]) Modifica: a. Calcula: quita los elementos repetidos de a. El límite inferior del array no varía, pero sí lo puede hacer el superior. A.E.D. 9 Tema 2. Abstracciones y especificaciones.

10. 2.2. Especificaciones informales: Abstracciones funcionales Ejemplo 2: concatenar dos cadenas. Operación concat (ent a,b: cadena; sal c: cadena) Calcula: la cadena de salida c es una nueva cadena que contiene los caracteres de a (en el mismo orden) seguidos de los caracteres de b (en el mismo orden). A.E.D. 10 Tema 2. Abstracciones y especificaciones.

11. 2.2. Especificaciones informales: Abstracciones funcionales Ejemplo 3: buscar un elemento en un array de enteros. Operación buscar (ent a: array [entero]; x: entero; sal i: entero) Requiere: que a esté ordenado de forma ascendente. Calcula: si x está en a, entonces i debe contener el valor del índice tal que a[i]=x. Si x no está en a, entonces i=sup+1, donde sup es el índice superior del array a. A.E.D. 11 Tema 2. Abstracciones y especificaciones.

12. 2.2. Especificaciones informales: Abstracciones funcionales Parametrización de tipo: una operación está definida independientemente del tipo de sus parámetros. Ejemplo 4: ordenar los elementos de un array. Operación ordenar [t: tipo] (ent a: array [t]; sal array [t]) Requiere: - t debe tener la operación Opertipo menorque (ent t,t; sal bool) - t debe estar totalmente ordenado. Modifica: a. Calcula: ordena según el orden determinado por menorque A.E.D. 12 Tema 2. Abstracciones y especificaciones.

13. 2.2. Especificaciones informales: Abstracciones funcionales Ejemplo 5: buscar un elemento en un array. Operación buscar [t: tipo] (ent a: array [t]; x: t; sal entero) Requiere: - t debe tener las operaciones Opertipo igual (ent t,t; sal bool) Opertipo menorque (ent t,t; sal bool) - t debe estar totalmente ordenado. Calcula: ...... buscando con la operación igual. A.E.D. 13 Tema 2. Abstracciones y especificaciones.

14. 2.2. Especificaciones informales: Abstracciones de datos. Notación TAD <nombre_tipo> es <lista_operaciones> Descripción Descripción textual del tipo Operaciones Especificación informal de las operaciones de la lista Fin <nombre_tipo> A.E.D. 14 Tema 2. Abstracciones y especificaciones.

15. 2.2. Especificaciones informales: Abstracciones de datos. Ejemplo 6: TAD conjunto de enteros. TAD Cjto_de_enteros es crear, insertar, suprimir, miembro, tamaño, elegir Descripción Los Cjto_de_enteros son cjtos. matemáticos modificables, que almacenan valores enteros. Operaciones Operación crear (sal Cjto_de_enteros) Calcula: devuelve un conjunto de enteros vacío. Operación insertar (ent c: Cjto_de_enteros; x: entero) Modifica: c. Calcula: añade x a los elementos de c; después de la inserción, el nuevo conjunto es un conjunto cpost, posterior a la inserción (cpost = c U {x}). A.E.D. 15 Tema 2. Abstracciones y especificaciones.

16. 2.2. Especificaciones informales: Abstracciones de datos. Ejemplo 6: TAD conjunto de enteros. Operación suprimir (ent c: Cjto_de_enteros; x: entero) Requiere: que c no sea vacío. Modifica: c. Calcula: suprime x de c (cpost = c - {x}). Operación miembro (ent c: Cjto_de_enteros; x: entero; sal bool) Calcula: devuelve true si x está en c, y false si no. Operación tamaño (ent c: Cjto_de_enteros; sal entero) Calcula: devuelve el cardinal del conjunto c. Operación elegir (ent c: Cjto_de_enteros; sal entero) Requiere: que c no sea vacío. Calcula: devuelve un valor arbitrario de c. Fin Cjto_de_enteros. A.E.D. 16 Tema 2. Abstracciones y especificaciones.

17. 2.2. Especificaciones informales: Abstracciones de datos. Ejemplo 7: TAD polinomio. TAD polinomio es crear, grado, coef, sumar, multiplicar, restar, menos, igual Descripciónpolinomio son polinomios de coeficientes enteros no modificables. Operaciones Operación crear (ent c,n: entero; sal polinomio) Requiere: n  0. Calcula: devuelve el polinomio cxn. Operación grado (ent p: polinomio; sal entero) Calcula: el entero que es el grado del polinomio. Operación coef (ent p: polinomio; n: entero; sal entero) Requiere: n  0. Calcula: devuelve el coeficiente del término del polinomio p cuyo exponente sea n. Si n es mayor que el término de mayor grado o si no está, devuelve 0. A.E.D. 17 Tema 2. Abstracciones y especificaciones.

18. 2.2. Especificaciones informales: Abstracciones de datos. Ejemplo 7: TAD polinomio. Operación sumar (ent p,q: polinomio; sal polinomio) Calcula: devuelve un polinomio suma de p y q. Operación multiplicar (ent p,q: polinomio; sal polinomio) Calcula: ... Operación restar (... Calcula: ... Operación menos (ent p: polinomio; sal polinomio) Calcula: devuelve z – p, donde z es el polinomio 0. Operación igual (ent p,q: polinomio; sal bool) Calcula: devuelve true si p y q tienen los mismos coeficientes para todos los términos del mismo grado, y, si no, devuelve false. Fin polinomio. A.E.D. 18 Tema 2. Abstracciones y especificaciones.

19. 2.2. Especificaciones informales: Abstracciones de datos. Ejemplo 8: conjuntos. TAD Cjto [t: tipo] es crear, insertar, suprimir, miembro, tamaño, elegir. Requiere: t debe tener la operación Opertipo igual (ent t,t; sal bool) Descripción <descripción general del tipo> Operaciones Operación crear (sal Cjto [t]) Calcula: ... ... A.E.D. 19 Tema 2. Abstracciones y especificaciones.

20. 2.2. Especificaciones informales: Abstracciones de datos. Ejemplo 9: listas. TAD lista [t: tipo] es crear, construir, primero, resto, vacía, igual. Descripción Son secuencias inmutables no acotadas de elementos de tipo t. Operaciones Operación crear (sal lista [t]) Calcula: devuelve una lista vacía. Operación construir (ent x: lista [t]; i: t; sal lista [t]) Calcula: devuelve una lista que contiene i como primer elemento, y los elementos de x como el resto. Operación primero (ent x: lista [t]; sal t); Requiere: que x sea no vacía. Calcula: devuelve el primer elemento de la lista. A.E.D. 20 Tema 2. Abstracciones y especificaciones.

21. 2.2. Especificaciones informales: Abstracciones de iteradores. • Ejemplo: Sobre el TAD Conjunto_de_enteros queremos añadir operaciones para calcular la suma, el producto, ... Operación suma_conj (ent c: conj_enteros; sal entero)Calcula: devuelve la suma de los elementos de c. .... Operación producto_conj (ent c: conj_enteros; sal entero) .... Operación varianza_conj (ent c: conj_enteros; sal real) .... A.E.D. 21 Tema 2. Abstracciones y especificaciones.

22. 2.2. Especificaciones informales: Abstracciones de iteradores • Es más adecuado tener una abstracción de la forma: For cada elemento i del conjunto A Do acción sobre i • Abstracción de iteradores: Una de las entradas puede ser la función que se aplica a los elementos: Iterador <nombre>(ent <id>:<tipo>;...; sal <tipores>) Requiere: ... Modifica: ... Calcula: ... A.E.D. 22 Tema 2. Abstracciones y especificaciones.

23. 2.2. Especificaciones informales: Abstracciones de iteradores • Ejemplo: Iterador ParaTodoHacer[T:tipo] (ent C:conjunto; accion: operacion) Requiere: accion es una operación que requiere parámetro de tipo T y no devuelve nada. Calcula: recorre todos los elementos del conjunto C y realiza sobre ellos la accion. A.E.D. 23 Tema 2. Abstracciones y especificaciones.

24. 2.2. Especificaciones informales: Abstracciones de iteradores • Se puede hacer a través de un TAD: TipoIterador <nombre> es <lista_operaciones>) Requiere: requisitos del iterador. Descripción: del significado y uso del iterador. Operaciones: especificación de cada operación de la lista A.E.D. 24 Tema 2. Abstracciones y especificaciones.

25. 2.2. Especificaciones informales: Abstracciones de iteradores TipoIterador IteradorPreorden [T: tipo] es Iniciar, Actual, Avanzar, EsUltimo Descripción Los valores de tipo IteradorPreorden[T] son iteradores definidos sobre árboles binarios de cualquier tipo T. Los elementos del árbol son devueltos en preorden. El iterador se debe inicializar con Iniciar. Operaciones Operación Iniciar (ent A: ArbolBinario[T]; sal IteradorPreorden) Calcula Devuelve un iterador nuevo, colocado sobre la raíz de A. Operación Actual (ent iter: IteradorPreorden; sal T) Calcula Devuelve el elemento actual en la iteración. Operación Avanzar (ent iter: IteradorPreorden) Requiere EsUltimo(iter) debe ser falso. Modifica iter Calcula Avanza el iterador iter al siguiente elemento en preorden, dentro del árbol binario sobre el que fue creado. Operación EsUltimo (ent iter: IteradorPreorden; sal booleano) Calcula Devuelve verdadero si y sólo si el elemento actual de la iteración es el último. Fin IteradorPreorden. A.E.D. 25 Tema 2. Abstracciones y especificaciones.

26. 2.3. Especificaciones formales. • Las especificaciones en lenguaje natural son ambiguas e imprecisas. • Especificaciones formales: definen un TAD o una operación de manera precisa, utilizando un lenguaje matemático. • Ventajas de una especificación formal: • Prototipado. Las especificaciones formales pueden llegar a ser ejecutables. • Correccióndelprograma. Verificación automática y formal de que el programa funciona correctamente. • Reusabilidad. Posibilidad de usar la especificación formal en distintos ámbitos. A.E.D. 26 Tema 2. Abstracciones y especificaciones.

27. 2.3. Especificaciones formales. Notación La descripción formal constará de cuatro partes: • NOMBRE. Nombre genérico del TAD. • CONJUNTOS. Conjuntos de datos que intervienen en la definición. • SINTAXIS. Signatura de las operaciones definidas. • <nombre_operación> : <conj_dominio>  <conj_resultado> • SEMÁNTICA. Indica el significado de las operaciones. A.E.D. 27 Tema 2. Abstracciones y especificaciones.

28. 2.3. Especificaciones formales. • Los distintas notaciones formales difieren en la forma de definir la semántica: • Método axiomático o algebraico. Se establece el significado de las operaciones a través de relaciones entre operaciones (axiomas). Significado implícito de las operaciones. • Método constructivo u operacional. Se define cada operación por sí misma, independientemente de las otras. Significado explícito de las operaciones. A.E.D. 28 Tema 2. Abstracciones y especificaciones.

29. 2.3.1. Método axiomático. • Supongamos un TAD, T. • Tipos de operaciones • Constructores. Conjunto mínimo de operaciones del TAD, a partir del cual se puede obtener cualquier valor del tipo T. c1:  T, c2: V  T, c3: V1x...xVn T • Modificación. A partir de un valor del tipo obtienen otro valor del tipo T, y no son constructores. m1: T  T, m2: TxV  T, m3: TxV1x...xVn T • Consulta. Devuelven un valor que no es del tipo T. o1: T  V, o2: TxV  V’, o3: TxV1x...xVn Vn+1 A.E.D. 29 Tema 2. Abstracciones y especificaciones.

30. 2.3.1. Método axiomático: ejemplo de TAD Booleano • NOMBRE Booleano • CONJUNTOS B conjunto de valores booleanos, U conjunto universal. • SINTAXIS verdadero :  B ; falso :  B ; Not : B  B ; And : B×B B ; Or : B×B B ; Si : B×B B ; • SEMÁNTICA para todo b en B y u1 y u2 en U • Not (verdadero)=falso • Not (falso)=verdadero • And (verdadero,b)=b • ... A.E.D. 30 Tema 2. Abstracciones y especificaciones.

31. 2.3.1. Método axiomático: TAD números naturales NOMBRE natural CONJUNTOS N conjunto de naturales, B conjunto de valores booleanos SINTAXIS cero:  N sucesor: N  N escero: N  B igual: N x N  B suma: N x N  N SEMANTICA m, n  N 1.escero (cero) = true 2.escero (sucesor (n)) = false 3.igual (cero, n) = escero (n) 4.igual (sucesor (n), cero) = false 5.igual (sucesor (n), sucesor (m)) = igual (n, m) 6.suma (cero, n) = n 7.suma (sucesor (m), n) = sucesor (suma (m, n)) A.E.D. 31 Tema 2. Abstracciones y especificaciones.

32. 2.3.1. Método axiomático. • Una especificación es completa si de cualquier expresión se puede encontrar otra más sencilla, con operaciones de construcción. • Una especificación es correcta si a partir de una expresión sólo se puede obtener un resultado final. • ¿Cómo garantizar que una especificación es completa y correcta? • Definir los axiomas suficientes para relacionar las operaciones de modificación y consulta con los constructores. • No incluir axiomas que se puedan deducir de otros existentes. A.E.D. 32 Tema 2. Abstracciones y especificaciones.

33. 2.3.1. Método axiomático: Especificación del TAD pila. NOMBRE pila (elemento) CONJUNTOS S conjunto de pilas, I conjunto de elementos, B conjunto de valores booleanos SINTAXIS crearpila:  S esvacíapila:S  B sacar: S  S cabeza: S  I meter: I x S  S En el caso de cabeza: S  I, ¿qué pasa si S es vacía? Se puede añadir un conjunto de mensajes en CONJUNTOS, de la forma: M conjunto de mensajes {‘la pila está vacía’} y variar en la parte de SINTAXIS la operación cabeza: cabeza: S  I U M A.E.D. 33 Tema 2. Abstracciones y especificaciones.

34. 2.3.1. Método axiomático: Especificación del TAD pila. Para obtener la semántina relacionar las modificaciones y consultas con los constructores  SEMANTICA i  I ,  s  S 1.esvacíapila (crearpila) = true 2.esvacíapila (meter (i, s)) = false 3.sacar (crearpila) = crearpila 4.sacar (meter (i,s)) = s 5.cabeza (crearpila) = ‘la pila está vacía’ 6.cabeza (meter (i, s)) = i Podemos hacer una pequeña modificación: supongamos que sacar, cuando se aplica a la pila vacía, devuelve el mensaje ‘la pila está vacía’. Quedaría: sacar (crearpila) = ‘la pila está vacía’ En la sintaxis, sacar quedaría de la forma: sacar: S  S U M  ¿Qué debemos cambiar si queremos que cabeza también saque el elemento de la pila? A.E.D. 34 Tema 2. Abstracciones y especificaciones.

35. 2.3.1. Método axiomático: Especificación del TAD bolsa. Para facilitar la escritura de la expresión del resultado en la parte semántica, se pueden emplear expresiones condicionales: SI <condición>  <valor si cierto> | <valor si falso> Ejemplo: TAD bolsa (colección de elementos, no ordenados, con repetición). NOMBRE bolsa (elemento) CONJUNTOS S conjunto de bolsas, I conjunto de elementos, B conjunto de valores booleanos, N naturales SINTAXIS bolsavacía:  S , poner: S x I  S , esvacía: S  B , cuántos: S x I  N SEMANTICA i, j  I ,  s  S     cuántos (bolsavacía, i) = cero cuántos (poner (s, j), i) = SI j = i  sucesor (cuántos (s, i)) | cuántos (s, i) · A.E.D. 35 Tema 2. Abstracciones y especificaciones.

36. 2.3.1. Método axiomático. • Ejecución de una especificación formal: aplicar sucesivamente las reglas de la semántica. Reducción de la expresión Suma(sucesor(sucesor(cero)),sucesor(cero)) Suma (sucesor(sucesor(cero)), sucesor(cero)) = Axioma 7, con n= sucesor(cero), m= sucesor(cero) sucesor (Suma (sucesor(cero), sucesor(cero))) = Axioma 7, con n= cero, m= sucesor(cero)] sucesor(sucesor(Suma (cero, sucesor(cero)))) = Axioma 6, con n=sucesor(cero) sucesor(sucesor(sucesor(cero))) A.E.D. 36 Tema 2. Abstracciones y especificaciones.

37. 2.3.2. Método constructivo. • Se diferencia del axiomático en la semántica. • Para cada operación, se establecen las precondiciones y las postcondiciones. • Precondición: Relación que se debe cumplir con los datos de entrada para que la operación sepueda aplicar. • Postcondición: Relaciones que se cumplen después de ejecutar la operación. No debe incluir detalles de implementación. Notación Para cada operación <nombre>: pre-<nombre> (<param_entrada>)::= <condición_lógica> post-<nombre> (<param_entrada>;<param_salida>)::= <condición_lógica> A.E.D. 37 Tema 2. Abstracciones y especificaciones.

38. 2.3.2. Método constructivo. • Ejemplo: operación máximo, que tiene como entrada dos números reales y da como salida el mayor de los dos. máximo: R x R  R (SINTAXIS) pre-máximo (x, y) ::= true (SEMANTICA) post-máximo (x, y; r) ::= (r  x)  (r  y)  (r=x  r=y)  • Ejemplo: máximo restringido, que sólo se aplica a enteros positivos. max_restring: Z x Z  Z pre-max_restring (x, y) ::= (x > 0)  (y > 0) post-max_restring (x, y; r) ::= (r  x)  (r  y)  (r=x  r=y) ¿Qué sucedería si x o y no son mayores que 0? No se cumple la precondición  no podemos asegurar que se cumpla la postcondición. A.E.D. 38 Tema 2. Abstracciones y especificaciones.

39. 2.3.2. Método constructivo. • Ejemplo: máximo restringido, que sólo se aplica a enteros positivos. Otra posibilidad: Definir un conjunto M (de mensajes de error) y cambiar la imagen. Modificar la sintaxis y la semántica: max_restring: Z x Z  Z U M pre-max_restring (x, y) ::= true post-max_restring (x, y; r) ::= if (x > 0)  (y > 0) then (r  x)  (r  y)  (r=x  r=y) else r = ‘fuera de rango’ A.E.D. 39 Tema 2. Abstracciones y especificaciones.

40. 2.3.2. Método constructivo. • Programación por contrato (tomado de OO). • Contrato de una operación: si se cumplen unas condiciones en los parámetros de entrada, entonces garantiza una obtención correcta del resultado. • La operación no trata todos los casos de error, sino que hace uso de las precondiciones. • La responsabilidad de comprobar la condición de error es del que usa la operación. • Si no se cumple la precondición se puede: • No especificar nada. • Generar una excepción. • Incluir el tratamiento de errores en la especificación. A.E.D. 40 Tema 2. Abstracciones y especificaciones.

41. 2.3.2. Método constructivo. Algunas veces es necesario tener tipos subyacentes para especificar otros complejos. Ej: para especificar Pila[T] o Cola[T] el tipo subyacente puede ser Lista[T]. Ejemplo: TAD cola. Definiremos el TAD lista mediante el método axiomático, y luego lo usaremospara definir el TAD cola con el método constructivo. A.E.D. 41 Tema 2. Abstracciones y especificaciones.

42. 2.3.2. Método constructivo. NOMBRElista (elemento) CONJUNTOSL conjunto de listas , I conjunto de elementos , B booleanos , N naturales , M conjunto de mensajes {‘la lista está vacía’} SINTAXIS crearlista:  L formarlista: I  L concatenar: L x L  L último: L  I U M cabecera: L  L primero: L  I U M cola: L  L longitud: L  N eslistavacía: L  B A.E.D. 42 Tema 2. Abstracciones y especificaciones.

43. 2.3.2. Método constructivo. SEMANTICA i  I  a,b  L  1. último (crearlista) = ‘la lista está vacía’ 2.    último (formarlista (i)) = i 3.    último (concatenar (a, b)) = SI eslistavacía (b)  último (a)| último (b) 4.    cabecera (crearlista) = crearlista 5.    cabecera (formarlista (i)) = crearlista 6.    cabecera (concatenar (a, b)) = SI eslistavacía (b)  cabecera (a) | concatenar (a, cabecera (b)) 7.    primero (crearlista) = ‘la lista está vacía’ 8.    primero (formarlista (i)) = i 9.    primero (concatenar (a, b)) = SI eslistavacía (a)  primero (b)| primero (a) 10.   cola (crearlista) = crearlista 11.   cola (formarlista (i)) = crearlista 12.   cola (concatenar (a, b)) = SI eslistavacía (a)  cola (b)| concatenar (cola (a), b) 13.   longitud (crearlista) = cero 14.   longitud (formarlista (i)) = sucesor (cero) 15.   longitud (concatenar (a, b)) = suma (longitud (a), longitud (b))  16.   eslistavacía (crearlista) = true 17.   eslistavacía (formarlista (i)) = false 18.   eslistavacía (concatenar (a, b)) = eslistavacía (a) AND eslistavacía(b) A.E.D. 43 Tema 2. Abstracciones y especificaciones.

44. 2.3.2. Método constructivo. Ejemplo: definición del tipo cola, con subyacente lista. NOMBREcola (elemento) CONJUNTOS Q conjunto de colas, I conjunto de elementos, B booleanos SINTAXIS crearcola:  Q, frente: Q  I, supcola: Q  Q, inscola: I x Q  Q, esvacíacola: Q  B SEMANTICA iI;  qQ; bB; rQ; pI; pQ pre-crearcola () ::= true post-crearcola (q) ::= q = crearlista pre-frente (q) ::= not eslistavacía (q) post-frente(q; p) ::= p = primero (q) pre-inscola (i, q) ::= true post-inscola (i, q; r) ::= r = concatenar (q, formarlista (i)) pre-supcola (q) ::= not eslistavacía (q) post-supcola (q; t) ::= t = cola (q) pre-esvacíacola (q) ::= true post-esvacíacola (q; b) ::= b = eslistavacía (q) A.E.D. 44 Tema 2. Abstracciones y especificaciones.

45. 2.3. Métodos formales. • La ejecución de especificaciones constructivas se puede simular. Si la precondición es cierta se puede dar por cierta la postcondición, si no lo es se produce un error. • En C++ se puede incluir la función assert(condicion) para comprobar que se cumple la pre o postcondición. Si es falsa se genera una excepción. A.E.D. 45 Tema 2. Abstracciones y especificaciones.