Lenguajes de Programación Tema 3. Paradigma Imperativo

Presentación del tema: "Lenguajes de Programación Tema 3. Paradigma Imperativo"— Transcripción de la presentación:

1 Lenguajes de Programación Tema 3. Paradigma Imperativo
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; A copy of the license is available at:

3 Indice Introducción Estudio de caso: Pascal Estudio de caso: ADA
ADA Avanzado Conclusiones

4 Pascal Objetivo: lenguaje para enseñar a programar, eficiente, elegante y simple. Influido por Algol-60. Valores y tipos: Tipos Primitivos: Integer, Real, Boolean Tipos compuestos: record, variant recor, array y punteros. Tipado estáticamente. Punteros para representar tipos recursivos.

5 Pascal Ejemplos: type letter = ‘A’..’Z’; var profile : array[letter]of
record frequency: o .. Maxint; followers: set of Letter; end; var letter1, letter2: LETTER; for letter1 := ‘A’ to ‘Z’ do begin write (profile[letter1].frequency); (...)

6 Pascal Expresiones No tiene expresiones condicionales n iexpresiones de bloque No tiene agregados y las funciones no pueden devolver resultados compuestos. Actualización selectiva y no total de tipos compuestos. El cuerpo de una expresion es un comando e implica una asignación.

7 Pascal Comandos y secuenciadores if , case,while, repeat, for. goto.
Declaraciones Deben ser declaradas en la cabecera y agrupadas por categorias. Dificulta la programación modular. const (...) type var

8 Pascal Abstracciones:
Procedimientos y funciones. No son valores de primer clase, pueden ser pasados como parametro pero no pueden ser asignados ni utilizqados como componentes de tipos compuestos. Paso de parámetros: valor, variable, procedural y funcional. No soporta encapsulación y modularidad, ni tipos abstractos, ni ocultación de informacion, ni genericidad, ni polimorfismo, ni excepciones.

9 Ada Objetivo: Lenguaje de proposito general. Con influencia de Algol-60, Simula y Pascal. Lenguaje mas moderno Valores, tipos y subtipos Similar a Pascal, tambiém necesita punteros para representar tipos recursivos. El lenguaje no los incluye. Expresiones Como Pascal tiene un conjunto muy limitado de expresiones, no incluye expresiones condicionales ni expresiones de bloque. Si tiene agregados.

10 Ada Comandos y secuenciadores
Similar a Pascal, pero con el exit y return permite escapes de una sola entrada y posibles salidas. Incluye una forma segura de manejo de excepciones. Declaraciones Permite la declaración de tipos y subtipos, constantes y variables, procedimientos y funcines, paquetes, tareas y excepciones. Las declaraciones se pueden situar en bloques de comandos.

11 Ada Abstracciones Soporta abstracciones procedurales y funcionales. Las abstracciones no son valores de primera clase y de hecho no pueden ser pasados como argumentos a otras abstracciones. Paso de parámetros: in, out, in out. Encapsulación Soporta paquetes, ocultacion de informacion, compilacion separada y genericidad.

12 Programación modular Ada Library Ada Library with ...
procedure Some_Main is begin …. end Some_Main;

13 hello.adb fact.adb main.adb with Text_IO; use Text_IO;
procedure Hello is begin Put_Line (“Hello”); end Hello; hello.adb function Fact (N : Integer) return Integer is begin if N <= 1 then return 1; else return N * Fact (N-1); end if; end Fact; fact.adb with Hello; with Fact; procedure Main is begin for I in 1 .. Fact (4) loop Hello; end loop; end Main; main.adb

14 Tipos Escalares Escalares Access (punteros) Discretos Reales
integer (Integer) enumeration (Boolean, Character) Reales floating point (Float) Access (punteros)

15 Enteros function Compute (P, Q : Integer) return Integer is
R : Integer; M : Integer := 2 * P; begin R := Q / M; return R; end Compute;

16 Creación de nuevos tipos
function Compute (P, Q : Integer) return Integer is type My_Int is range _000_000; T : My_Int; begin T := P + 1; T := My_Int (P) + 1; return Integer (T) + Q; end Compute; Error de compilación Conversión explícita

17 Tipos Enumerados procedure Compute (A : Character; B : Boolean) is
type Day is (Mon, Tue, Wed, Thu, Fri, Sat, Sun); D : Day := Wed; C : Character := ‘W’; Week_Day : Boolean := D in Mon .. Fri; Lower_Case : Boolean := A in ‘a’ .. ‘z’; begin Week_Day := Week_Day or B; end Compute;

18 Reales procedure Compute (M : Integer) is Pi : constant := 3.141;
F : constant Float := Float (M); R : Float := F * Pi; A : Integer := Integer (R); begin null; end Compute; Conversiones explícitas

19 Desbordamiento in C #include <limits> void main {
int k = INT_MAX; k = k + 1; }

20 Desbordamiento & controles
procedure Checks is K : Integer := Integer ’ Last; begin K := K + 1; end Checks; Constraint Error % gnatmake -q checks % checks raised CONSTRAINT_ERROR %

21 Subtipos type Day_Of_A_Month is range 1 .. 31;
type Day_Of_February is range ; D1 : Day_Of_February := 25; D2 : Day_Of_A_Month := D1; D2 : Day_Of_A_Month := Day_Of_A_Month (D1); Error de compilación OK

22 type Day_Of_A_Month is range 1 .. 31;
subtype Day_Of_February is Day_Of_A_Month range ; D1 : Day_Of_February := 25; D2 : Day_Of_A_Month := D1; OK D3 : Day_Of_A_Month; D4 : Day_Of_February := D3; Que ocurre aquí ?

23 Excepciones procedure Checks is A : Integer := Integer ’ First; begin
A := A - 1; end Checks; Que ocurre aquí ? % gnatmake -q checks % checks raised CONSTRAINT_ERROR %

24 Excepciones predefinidas
Constraint_Error: overflow, computation error (divide by zero), array index out of range, … Storage_Error: no more memory available Program_Error: fundamental program error (e.g. end of function with no return statement)

25 Captura de excepciones
with Text_IO; use Text_IO; procedure Checks is A : Integer := Integer ’ First; begin A := A - 1; exception when Constraint_Error => Put_Line (“Overflow occurred”); end Checks; % gnatmake -q checks % checks Overflow occurred %

26 Creación de Excepciones
procedure Checks is Internal_Error : exception; Creación de Excepciones procedure Foo is begin raise Internal_Error; end Foo; procedure Bar is begin Foo; end Bar; begin Bar; exception ... end Checks; Exception Handler

27 Exception Handler procedure Foo is begin raise Internal_Error;
end Foo; procedure Bar is Foo; end Bar; Bar; exception when Internal_Error => Put_Line (“problem occurred”); when others => Put_Line (“some other exception”); end Checks; Exception Handler

28 Exception Handler procedure Foo is begin raise Internal_Error;
end Foo; procedure Bar is Foo; end Bar; Bar; exception when Internal_Error => Put_Line (“problem occurred”); when others => Put_Line (“some other exception”); end Checks; 1 2 3 4 5 Exception Handler

29 procedure Foo is begin raise Internal_Error; end Foo; procedure Bar is Foo; end Bar; Bar; exception when Internal_Error => Put_Line (“problem occurred”); when others => Put_Line (“some other exception”); end Checks; 1 2 3 4 5

30 inicializan a null por defecto
Tipos Access type Int_Ptr is access Integer; P : Int_Ptr; Los punteros se inicializan a null por defecto

31 Tipos compuestos array (String) record tagged record protected types
tasks

32 Arrays procedure Compute (N : Integer) is A : array (1 .. N) of Float;
begin for I in 1 .. N loop A (I) := 3.141; end loop; end Compute; Arrays pueden tener - límites dinámicos - tamaño dinámico

33 Arrays tipados procedure Compute (N : Integer) is
type Arr is array (Integer range <>) of Float; A : Arr (1 .. N); B : Arr := A; B toma sus limites de A C : Arr ( ); begin C := A Constraint_Error Si C’Length /= A’Length C ( ) := A (5 .. 8); Constraint_Error Si A’Last < 8

34 Atributos de Array ARRAY ’ First : menor índice en ARRAY
ARRAY ’ Last : mayor índice en ARRAY ARRAY ’ Length : número de elementos ARRAY ARRAY ’ range : ARRAY ’ First .. ARRAY ’ Last

35 type Vector is array (Natural range <>) of Float;
function Max (V : Vector) return Float is M : Float := Float ’ First; begin for I in V ’ range loop if V (I) > M then M := V (I); end if; end loop; return M; end Max;

36 type Vector is array (Natural range <>) of Float;
function Max (V : Vector) return Float; V1 : Vector := (0.0, 1.0, 2.0, 3.0, 4.0, 5.0); V2 : Vector ( ) := (1.0, 2.0, others => 99.0); X : Float := Max (V1); Y : Float := Max (V2); V1’First = 0 V1’Last = 6 V1’Length = 7 V2’First = 1 V2’Last = 100 V2’Length = 100

37 Array predefinido type String is array (Positive range <>) of Character; R : String ( ); S : String := (‘H’, ‘e’, ‘l’, ‘l’, ‘o’); T : String := “Hello”; Q : String := S & “ “ &T “ you”; Q = “Hello Hello You”

38 Tipos Record type Date is record Day : Positive range 1 .. 31;
Month : Positive range ; Year : Integer; end record; D : Date := (3, 9, 1975); A : Date := (Day => 31, Month => 12, Year => 1999); B : Date := A; Y : Integer := B . Year;

39 Memoria type Node; type Node_Ptr is access Node; type Node is record
3 9 1975 P2 type Node; type Node_Ptr is access Node; type Node is record D : Date := (1, 1, 1900); Next : Node_Ptr; end record; P1 : Node_Ptr := new Node; P1 1 1900 null P2 : Node_Ptr := new Node ’ ((3, 9, 1975), P1); Memoria

40 Paso de Parámetros in (functions & procedures) in out (solo procedures) out (solo procedures)

41 Estructuras de control
if-then-else case Iteradores for while

42 Programación modular Especificación & Implementación
Tipos Abstractos de datos Paquetes jerárquicos

43 Compilación separada THE PROBLEM Compiler object Linker executable
CODE Linker executable libraries Compiler object CODE Compiler object CODE

44 Problemas Sin estructura
CODE CODE CODE CODE CODE Sin estructura Para escribir código debes conocer TODO el código que utilices

45 Idea Especificar que debería hacer cada módulo

46 ESPECIFICACION ? Implementación Módulo

47 Una especificación es ... CONTRATO
Cliente del Módulo Desarrollador Del módulo CONTRATO Sobre los SERVICIOS que ofrece el módulo

48 Service_1 Service_2 Service_3
SPEC = lista de servicios BODY = implementación de los servicios (oculta) Service_1 Service_2 Service_3 Service_1 implementation Service_2 Service_3 Módulo Software

49 SPECIFICATION ? BODY

50 Ejemplo Crear un módulo Cola que permita: Añadir un Integer a la Cola
Ver el primer integer de la cola Obtener el primer integer de la cola Ver si la cola está vacia

51 queue.ads package Queue is procedure Add (Element : Integer); function First return Integer; function Get return Integer; function Empty return Boolean; end Queue;

52 ? BODY package Queue queue.ads package Queue is
procedure Add (Element : Integer); function First return Integer; function Get return Integer; function Empty return Boolean; end Queue; ? BODY package Queue

53 Utilizando Queue with Queue; procedure Client is
client.adb with Queue; procedure Client is Queue_Error : exception; X : Integer; begin Queue.Add (3); Queue.Add (4); if not Queue.Empty then X := Queue.Get; else raise Queue_Error; end if; end Client;

54 Las especifications reducen la complejidad
Para escribir tu propio código: Solo es necesario entender la especificación de los servicios utilizados

55 Use with Queue; use Queue; procedure Client is
Queue_Error : exception; X : Integer; begin Queue. Add (3); Queue. Add (4); if not Queue. Empty then X := Queue. Get; else raise Queue_Error; end if; end Client;

56 Una posible implementación del package Queue

57 Buffer Circular Q 1 Q_Last Q_First Max_Size - 1

58 queue.adb package body Queue is Max_Size : constant := 100; type Q_Index is mod Max_Size; Q : array (Q_Index range 0 .. Max_Size - 1) of Integer; Q_First : Q_Index := Q ’ First; Q_Last : Q_Index := Q_First; Size : Natural range 0 .. Max_Size; procedure Add (Element : Integer) is begin Q (Q_Last) := Element; Q_Last := Q_Last + 1; Size := Size + 1; end Add; ... end Queue;

59 queue.adb package body Queue is ... function First return Integer is begin return Q (Q_First); end First; function Get return Integer is Q_First := Q_First + 1; Size := Size - 1; return Q (Q_First - 1); end Get; function Empty return Boolean is return Size = 0; end Empty; end Queue;

60 Otra posible implementación del package Queue

61 Lista enlazada Q_Last Q_First Free

62 queue.adb package body Queue is type Queue_Element; type Element_Ptr is access Queue_Element; type Queue_Element is record Val : Integer; Next : Element_Ptr; end record; Q_First : Element_Ptr; Q_Last : Element_Ptr; Free : Element_Ptr := new Queue_Element; ... end Queue;

63 queue.adb package body Queue is ... procedure Add (Element : Integer) is begin if Q_First = null then Q_First := Free; else Q_Last.Next := Free; end if; Q_Last := Free; Free := Free.Next; Q_Last.all := (Element, null); if Free = null then Free := new Queue_Element; end Add; end Queue;

64 queue.adb package body Queue is ... function Get return Integer is Tmp : Element_Ptr := Q_First; begin Q_First := Q_First.Next; if Q_First = null then Q_Last := null; end if; Tmp.Next := Free; Free := Tmp; return Tmp.Val; end Get; end Queue;

65 queue.adb package body Queue is ... function First return Integer is begin return Q_First; end First; function Empty return Boolean is return Q_First = null; end Empty; end Queue;

66 Una Especificación puede tener varias implementaciones
queue.ads package Queue is procedure Add (Element : Integer); function First return Integer; function Get return Integer; function Empty return Boolean; end Queue; Podemos cambiar la implementación SIN cambiar el código cliente A B

67 En Ada La Spec siempre se chequea con su implementación
Obligatorio incluir with de las specs que vayas a usar (no como en C) Multiples espacios de nombres

68 Spec se chequea con el cuerpo
package Queue is procedure Add (Element : Integer); ... end Queue; Que ocurre aquí ? package body Queue is ... procedure Add (Element : Integer; X : Float) is end Add; end Queue;

69 Múltiples espacios de nómbres
package Queue is procedure Add (E : Integer); ... end Queue; package Set is procedure Add (E : Integer); ... end Set; with Queue; with Set; procedure Client is begin Queue.Add (3); Set.Add (99); end Client;

70 Privacidad y ocultación de información
Exponer las estructuras de datos es peligroso El código cliente puede manipular directamente las estructuras sin utilizar los servicios del módulo El código cliente es dificil de modificar

71 Tipos privados package Queues is type Queue is private;
procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue is …; end Queues;

72 En cualquier implementación
package Queues is type Queue is private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue_Element; type Element_Ptr is access Queue_Element; type Queue_Element is record Val : Integer; Next : Element_Ptr; end record; type Queue is record First : Element_Ptr; Last : Element_Ptr; end Queues;

73 … los tipos privados son PRIVADOS
with Queues; use Queues; procedure Client is Q1 : Queue; Q2 : Queue; begin Add (Q1, 123); Add (Q2, 3); Q2.Last := null; end Client; ¿ Que ocurre aquí ?

74 Ventajas de los tipos privados
Refuerzan el contrato de la especificación El código cliente no puede corromper tus estrucuras de datos Podemos cambiar la implementación sin modificar el código cliente

75 ¿Por qué lo privado está en el ADS?
package Queues is type Queue is private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue_Element; type Element_Ptr is access Queue_Element; type Queue_Element is record Val : Integer; Next : Element_Ptr; end record; type Queue is record First : Element_Ptr; Last : Element_Ptr; end Queues;

76 … porque necesitamos compilar el código cliente
with Queues; use Queues; procedure Client is Q1 : Queue; begin Add (Q1, 123); end Client;

77 … aunque todavía podemos ocultar más el tipo
package Queues is type Queue is private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue_Info; type Queue is access Queue_Info; end Queues;

78 package body Queues is type Queue_Element; type Element_Ptr is access Queue_Element; type Queue_Element is record Val : Integer; Next : Element_Ptr; end record; type Queue_Info is record First : Element_Ptr; Last : Element_Ptr; ... end Queues;

79 Tipos privados limitados
NO asignación := NO comparación =

80 package Queues is type Queue is limited private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue is …; end Queues;

81 with Queues; use Queues;
procedure Client is Q1 : Queue; Q2 : Queue; X : Integer; begin Add (Q1, 123); Add (Q1, 3); Q2 := Q1; end Client; ¿ Que ocurre aquí ?

82 Tipos Abstractos de Datos (TAD)
Conjunto de valores (datos del dominio) Colección de operaciónes (turinas que manipulan los valores) TAD =

83 Queue es un TDA valores operaciones package Queues is
type Queue is limited private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue is …; end Queues; operaciones

84 Objetos & Variables OBJETO = instancia de un TDA
VARIABLE = nombre de un objeto concreto

85 Un objeto My_Q : Queue; Queue object Nombre del obeto Memory

86 CLASE = TDA + herencia

87 operacion operacion operacion
Invocación de los servicios del TDA operacion operacion Datos Privados ENCAPSULACION

88 Modelo de Objetos

89 Modelo Procedural (C) DATOS GLOBALES C module C module C module

90 Para extender un paquete ...
function Last (Q : Queue) return Integer; function Last (Q : Queue) return Integer; package Queues is type Queue is private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue is …; end Queues; Queue is a private type

91 Pero ... Cada cambio en el ADS obliga a recompilar todos los clientes
Cada cambio en el módulo implica el test de toda la funcionalidad del módulo.

92 Solución: Paquetes hijos
queues.ads package Queues is type Queue is private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue is …; end Queues; function Queues . Last (Q : Queue) return Integer; queues-last.ads

93 Utilización: with Queues; use Queues; with Queues.Last;
procedure Client is Q : Queue; X : Integer; begin Add (Q, 123); Add (Q, 3); X := Queues.Last (Q); end Client;

94 Package hijo queues-new_functionality.ads
queues.ads package Queues is type Queue is private; procedure Add (Q : Queue; Element : Integer); function First (Q : Queue) return Integer; function Get (Q : Queue) return Integer; function Empty (Q : Queue) return Boolean; private type Queue is …; end Queues; package Queues . New_Functionality is function Last (Q : Queue) return Integer; end Queues . New_Functionality queues-new_functionality.ads Package hijo

95 with Queues; use Queues;
with Queues.New_Functionality; procedure Client is Q : Queue; X : Integer; begin Add (Q, 123); Add (Q, 3); X := Queues.New_Functionality.Last (Q); end Client;

96 Polimorfismo aparente: Sobrecarga
package Queue is procedure Add (E : Integer); procedure Add (E : Float); ... end Queue; with Queue; use Queue; procedure Client is begin Add (123); Add (3.141); end Client;

97 Polimorfismo paramétrico: Genericidad

98 Repetición de código... procedure Swap (X, Y : in out Integer) is
Tmp : Integer := X; begin X := Y; Y := Tmp; end procedure Swap (X, Y : in out Float) is Tmp : Float := X; begin X := Y; Y := Tmp; end

99 Esto... Implica coste de tiempo Susceptible a errores (Cortar & Pegar)
Díficil de mantener

100 La genericidad permite parametrizar código
gen_swap.ads generic type Some_Type is private; procedure Gen_Swap (X, Y : in out Some_Type); procedure Gen_Swap (X, Y : in out Some_Type) is Tmp : Some_Type := X; begin X := Y; Y := Tmp; end Gen_Swap; gen_swap.adb

101 Instanciación with Gen_Swap; procedure Client is
procedure Swap is new Gen_Swap (Some_Type => Integer); procedure Swap is new Gen_Swap (Some_Type => Float); A, B : Integer := …; P, Q : Float := …; begin Swap (A, B); Swap (P, Q); end Swap;

102 Tipos de unidades genéricas
generic … formal parameters ... procedure Proc (…); generic … formal parameters ... function Func (…) return …; generic … formal parameters ... package Pack is … end Pack;

103 … parámetros formales ... Types Objects Subprograms Packages

104 Ejemplo Escribir una función genérica que calcule donde
L & H son límites enteros F es una función que devuelve un valor Una operación de suma está disponible para ese valor

105 Spec ... generic type Res_Type is private; Zero : in Res_Type;
with function Add (X, Y : Res_Type) return Res_Type; with function F (I : Integer) return Res_Type; function Sum (L, H : Integer) return Res_Type;

106 Body ... function Sum (L, H : Integer) return Res_Type is
Result : Res_Type := Zero; begin for I in L .. H loop Result := Add (Result, F (I)); end loop; return Result; end Sum;

107 Instanciación with Sum; procedure Client is
function Compute (X : Integer) return Integer is … end; function Compute (X : Integer) return Float is … end; function New_Sum is new Sum (Res_Type => Integer, Zero => 0, Add => “+”, F => Compute); function New_Sum is new Sum (Res_Type => Float, Zero => 0.0,

108 Genericidad y paquetes

109 Genericidad y paquetes

110 Instanciación