parte1-fundamentos-ada-3en1

Parte I: Fundamentos de programación
en lenguaje Ada
UNIVERSIDAD
DE CANTABRIA
1. Elementos básicos del lenguaje
2. Estructuras de datos dinámicas
3. Modularidad y programación orientada a objetos
4. Tratamiento de errores
5. Abstracción de tipos mediante unidades genéricas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.1. Introducción
1
UNIVERSIDAD
DE CANTABRIA
Motivación para el lenguaje: "Crisis del software" de mediados de
los años 70
• gran número de lenguajes
• necesidad de introducir técnicas de ingeniería de software
- fiabilidad
- modularidad
- programación orientada a objetos (comenzaba en ese momento)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Principios de diseño del lenguaje
Ada 83
2
UNIVERSIDAD
DE CANTABRIA
• Fiabilidad
- legibilidad
- tipificación estricta
- excepciones
•
•
•
•
•
•
Modularidad
Abstracción de datos y tipos
Compilación separada
Concurrencia
Tiempo Real
Estandarizado
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3
Notas:
UNIVERSIDAD
DE CANTABRIA
• Legibilidad: Facilidad para entender el código al leerlo; esto fomenta la fiabilidad porque al entenderse
bien el código se cometen menos errores al escribirlo o modificarlo.
• Tipificación estricta: El lenguaje obliga a no mezclar datos de distintos tipos en expresiones, y así se
detectan más errores de manera automática.
• Excepciones: Mecanismo de tratamiento de errores que dificulta que éstos pasen inadvertidos.
• Modularidad: Capacidad para partir el programa en módulos o fragmentos independientes.
• Abstracción de tipos: Capacidad de hacer módulos independientes de un determinado tipo de datos.
• Abstracción de datos: Capacidad de hacer módulos con datos configurables.
• Compilación separada: Capacidad de compilar por separado los diferentes módulos del programa.
• Concurrencia: Capacidad para ejecutar a la vez varias partes del programa, que atienden de manera
simultánea a varios subsistemas o funcionalidades.
• Tiempo real: Capacidad para garantizar que los tiempos de respuesta del programa se adaptan a la
evolución del entorno exterior.
• Estandarización: Normativa clara y aceptada por consenso sobre los elementos que debe ofrecer el
lenguaje. La estandarización facilita que las aplicaciones se puedan portar de unos compiladores a
otros sin cambios.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Elementos introducidos por Ada 95
4
UNIVERSIDAD
DE CANTABRIA
• Mejor soporte a la programación orientada a objetos
- extensión de objetos
• Más eficiencia en concurrencia
• Mejor soporte de sistemas de tiempo real
Ada es un lenguaje que incorpora muchas recomendaciones que
provienen de la ingeniería de software
• recomendable para grandes proyectos de software
Los principios del Ada son recomendables para todos los
desarrollos software, incluso los realizados en otros lenguajes
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.2 Estructura de un programa
5
UNIVERSIDAD
DE CANTABRIA
with Nombres_de_Otros_Modulos_de_Programa;
procedure Nombre_Programa is
declaraciones;
begin
instrucciones;
end Nombre_programa;
Las declaraciones son:
• de datos: constantes, variables, tipos
• de fragmentos de programa: procedimientos, funciones,
paquetes
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
6
Notas:
UNIVERSIDAD
DE CANTABRIA
Un programa es un procedimiento (procedure) que a su vez puede invocar a otros.
• En C y Java es necesario que el programa sea una función o método llamado main
• En Java el procedimiento principal que forma un programa puede llamarse como se quiera
La instrucción with permite indicar nombres de módulos de programas que se van a usar.
El procedimiento tiene un encabezamiento, que contiene las palabras procedure e is, y el nombre del
procedimiento en medio. Este nombre lo elegimos nosotros.
Después del encabezamiento se ponen las declaraciones y las instrucciones. Éstas últimas se encierran
entre begin y end.
Las declaraciones crean elementos que se usarán desde las instrucciones.
Las instrucciones se ejecutan en el orden que se escriben, al invocar el procedimiento.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo:
7
UNIVERSIDAD
DE CANTABRIA
Programa que pone un mensaje en la pantalla:
with Ada.Text_IO;
procedure Sencillo is
-- sin declaraciones
begin
Ada.Text_IO.Put("Esto es un programa sencillo");
end Sencillo;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Comentarios sobre el ejemplo
8
UNIVERSIDAD
DE CANTABRIA
• Concepto de sangrado:
- legibilidad
- muestra visualmente la estructura del código
• Comentarios: comienzan por -- y acaban al final de la línea
• Las instrucciones y declaraciones acaban en ";". El programa
también
• Los nombres de identificadores:
-
comienzan por letra
siguen letras, números y "_"
no se distinguen mayúsculas de minúsculas
no es aconsejable usar acentos y ñ, por los problemas de
compatibilidad al pasar a otros sistemas operativos
- hay un conjunto de nombres reservados
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
9
Notas:
UNIVERSIDAD
DE CANTABRIA
El sangrado es muy importante para facilitar la comprensión del código. Ello facilita cometer menos errores
y contribuye por tanto a la fiabilidad.
Recomendación: Utilizar desde el principio los sangrados correctos.
Observar en este ejemplo que declaración-begin-end van alineados. Las declaraciones e instrucciones, que
están contenidas en el procedimiento, se sitúan alineadas pero más a la derecha.
El estilo habitual para los nombres de cosas en Ada es:
• primera letra de cada palabra en mayúsculas, resto en minúsculas
• separar cada palabra del nombre por el carácter ’_’
• usar nombres significativos (ej: Temperatura, Presion, en vez de a3, c5)
La instrucción Ada.Text_IO.Put_Line es equivalente al System.out.println() de Java, y similar,
aunque menos flexible, al printf() de C/C++
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Programa sencillo con ventanas
10
UNIVERSIDAD
DE CANTABRIA
with Message_Windows;
use Message_Windows;
procedure Sencillo is
Message : Message_Window_Type;
begin
Message:=Message_Window("Esto es un programa sencillo");
Wait(Message);
end Sencillo;
Message_Windows es un módulo software perteneciente a
Win_IO:
• No es estándar de Ada
• http://www.ctr.unican.es/win_io/
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
11
UNIVERSIDAD
DE CANTABRIA
La cláusula use permite omitir el nombre del módulo en adelante; es opcional
Message : Message_Window_Type permite crear una variable llamada Message, que representa un
dato con información, del tipo Message_Window_Type. Este dato contiene la información y operaciones
necesarias para pintar una ventana con texto en la pantalla.
En la instrucción Message:=Message_Window("Esto es un programa sencillo")
Message_Window es la llamada a un procedimiento que crea la ventana y le pone su texto. La ventana se
almacena en la variable Message.
Wait(Message) es la llamada a un procedimiento que espera hasta que el usuario confirma que ha leído
la ventana guardada en Message pulsando su botón "OK".
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
12
1.3. Variables, constantes, y tipos
simples
UNIVERSIDAD
DE CANTABRIA
La información se guarda en casillas de memoria, que son:
• variables: el contenido puede variar
- algunas tienen nombre
- otras se crean dinámicamente sin nombre (se verán más adelante)
• constantes: el contenido no puede variar
- las hay con nombre
- y sin nombre (literales): se pone directamente el valor
Todos los datos tienen siempre un tipo asociado:
• tipos predefinidos
• tipos definidos por el usuario
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.3.1. Tipos predefinidos
13
UNIVERSIDAD
DE CANTABRIA
Son:
Tipo
Valores
Integer
entero de 16 bits mínimo [-2**15..2**15-1]
Float
real de unos 6 dígitos como mínimo
Character
caracter de 8 bits (Wide_Character,
caracteres internacionales de 16 bits)
String (1..n)
texto, definido como una secuencia de n
caracteres
Boolean
Valor lógico: True o False
Duration
Tiempo: número real en segundos
Veremos más adelante que se pueden crear otros tipos, incluidos
enteros y reales
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
14
UNIVERSIDAD
DE CANTABRIA
El bit es la unidad de almacenamiento de información digital, y representa una cifra binaria (0 ó 1). Poniendo
muchos bits juntos podemos hacer muchas combinaciones de valores y representar números grandes.
La notación 2**15 significa 215
Se distinguen números enteros y reales porque cada uno tiene sus ventajas e inconvenientes:
• enteros: aritmética exacta, rango limitado
• reales: aritmética inexacta (sufren errores de redondeo), pero su rango de valores es mucho mayor
Los textos se forman con secuencias de muchos caracteres, que a su vez son valores del tipo Character
El tipo String representa un texto. Su tamaño se decide al ejecutar el programa (según el número de
caracteres que tenga) pero una vez definido no puede cambiar
• Veremos más adelante textos de tamaño variable
Los booleanos representan valores lógicos verdadero o falso, y se utilizan mucho para tomar decisiones en
las instrucciones condicionales.
El tipo Duration se usa para representar intervalos relativos de tiempo, en segundos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
15
Atributos de los tipos predefinidos:
Tipo
Atributo
UNIVERSIDAD
DE CANTABRIA
Descripción
enteros, reales
y enumerados
tipo’First
tipo’Last
tipo’Image(valor)
tipo’Value(string)
Primer valor
Último valor
Conversión a String
Conversión String a valor
numérico o enumerado
reales
tipo’Digits
tipo’Small
Número de dígitos
Menor valor positivo
discretos (enteros, caracteres
y enumerados)
tipo’Pos(valor)
tipo’Val(numero)
Código numérico de un valor
Conversión de código a valor
strings
s’Length (s es un
string concreto)
Número de caracteres del
string
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
16
UNIVERSIDAD
DE CANTABRIA
Los atributos son elementos del lenguaje que permiten obtener información sobre otro elemento,
generalmente un tipo, o un dato.
Los datos enumerados son datos cuyos valores son palabras o nombres; los veremos más adelante.
Usaremos con frecuencia el atributo Image, que permite la conversión a texto de un dato numérico o
enumerado, para poner resultados en la pantalla, ya que en ésta es más fácil escribir texto.
El atributo Pos permite obtener el código binario con el que el computador representa los caracteres o los
enumerados.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Componentes de los strings
17
UNIVERSIDAD
DE CANTABRIA
Caracteres individuales
s(i)
Rodajas de string (también son strings)
s(i..j)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
18
1.3.2. Constantes sin nombre o
literales
Números enteros
13 0 -12 1E7
16#3F8#
Números reales
13.0
0.0
UNIVERSIDAD
DE CANTABRIA
13_842_234
-12.0
1.0E7
Caracteres
’a’
’Z’
Strings
"texto"
Booleanos
True
False
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
19
UNIVERSIDAD
DE CANTABRIA
Los literales expresan un valor de un tipo determinado
En los números, los caracteres ’_’ se ignoran; se usan como separadores de millar
7
Enteros: se pone el valor. La notación 1E7 significa 1 ⋅ 10 . La notación 16#3F8# significa el número 3F8
expresado en base 16.
Reales: Se distinguen por la presencia de la parte fraccionaria separada por el ’.’ decimal. Es obligatorio
ponerla aunque sea cero.
Caracteres: se pone el carácter entre apóstrofes o comillas simples
Strings: se pone el texto entre comillas dobles
Booleanos: se pone el valor lógico (en inglés)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.3.3. Variables y constantes con
nombre
20
UNIVERSIDAD
DE CANTABRIA
Características
• Ocupan un lugar en la memoria
• tienen un tipo
• tienen un nombre : identificador
• las constantes no pueden cambiar de valor
Declaración de variables
identificador : tipo;
identificador : tipo:=valor_inicial;
Declaración de constantes:
identificador : constant := valor_inicial;
identificador : constant tipo:=valor_inicial;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
21
Ejemplos:
Numero_De_Cosas
Temperatura
Direccion
Esta_Activo
Simbolo
A,B,C
Max_Num
Pi
UNIVERSIDAD
DE CANTABRIA
:
:
:
:
:
:
:
:
Integer;
Float:=37.0;
String(1..30);
Boolean;
Character:=’a’;
Integer;
constant Integer:=500;
constant:=3.1416;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
22
UNIVERSIDAD
DE CANTABRIA
Puede observarse que las declaraciones van al revés que en Java/C: primero se pone la variable y luego
el tipo
Se puede elegir dar valor inicial o no a una variable
• Si no sabemos qué valor debe tener, es mejor no asignarlo porque así el compilador puede avisarnos
si nos equivocamos al usar la variable antes de darle valor
Para las constantes es obligatorio dar valor inicial. Si no ponemos el tipo, éste se infiere a partir del literal
El String Direccion tiene exactamente 30 caracteres, numerados de 1 a 30. Su tamaño es fijo.
En los booleanos es importante que el nombre indique lo que significa que la variable sea verdadera o falsa
• Esta_Activo es un buen ejemplo
• Estado es un mal nombre: no nos indica qué significa valer true o false
Se pueden crear varias variables de golpe, separándolas por comas, como las variables A,B,C del ejemplo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de un programa con objetos
de datos:
23
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_Io;
procedure Nombre is
Tu_Nombre,Tu_Padre : String (1..20);
N_Nombre,N_Padre
: Integer;
-- Ejemplo de uso de strings de tamaño variable
begin
Ada.Text_Io.Put("Cual es tu nombre?: ");
Ada.Text_Io.Get_Line(Tu_Nombre,N_Nombre);
Ada.Text_Io.Put("Como se llama tu padre?: ");
Ada.Text_Io.Get_Line(Tu_Padre,N_Padre);
Ada.Text_Io.Put_Line("El padre de "&
Tu_Nombre(1..N_Nombre)&
" es "&Tu_Padre(1..N_Padre));
end Nombre;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
24
Notas:
UNIVERSIDAD
DE CANTABRIA
En este ejemplo se crean cuatro variables: Dos son Strings y dos son enteros
El ejemplo muestra cómo manejar strings variables: se crea un string grande y se usa sólo una parte
• una variable entera guarda el número de caracteres válidos
Las operaciones de I/O usadas son:
• Put: Pone un texto en pantalla
• Put_Line: es igual que Put, pero añade al final del texto un salto de línea.
• Get_Line: Lee un string variable del teclado. Entre paréntesis se le pasan dos variables: un string y
un entero. El string leído es una secuencia de caracteres finalizada con un salto de línea. Los
caracteres se guardan en las primeras posiciones de la variable de tipo string. El salto de línea se lee,
pero no se incluye en la variable. El número de caracteres leídos se guarda en el entero.
Para usar la parte válida del string usamos una rodaja de string: s(1..N)
Usamos el operador de concatenación: &. Sirve para unir dos strings poniendo uno a continuación del otro
y formando uno solo. Es necesario, pues la operación Put o Put_Line sólo admite entre paréntesis un
único string.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
El mismo ejemplo, con cláusula “use”
25
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_Io;
use Ada.Text_Io;
procedure Nombre_Con_Use is
Tu_Nombre,Tu_Padre : String (1..20);
N_Nombre,N_Padre
: Integer;
-- Ejemplo de uso de strings de tamaño variable
begin
Put("Cual es tu nombre?: ");
Get_Line(Tu_Nombre,N_Nombre);
Put("Como se llama tu padre?: ");
Get_Line(Tu_Padre,N_Padre);
Put_Line("El padre de "&Tu_Nombre(1..N_Nombre)&
" es "&Tu_Padre(1..N_Padre));
end Nombre_Con_Use;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
A observar
26
UNIVERSIDAD
DE CANTABRIA
• Para strings de longitud variable
- Usamos un string grande y de él sólo una parte
- una variable entera nos dice cuántos caracteres útiles hay
• Uso de rodajas de string
- para coger la parte útil del string
• Text_IO: Put, Get_Line, Put_Line, New_Line
• Cláusula use
• Uso de variables
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
27
El mismo ejemplo, con ventanas
UNIVERSIDAD
DE CANTABRIA
with Input_Windows;
use Input_Windows;
procedure Nombres is
Tu_Nombre,Tu_Padre : String (1..20);
N_Nombre,N_Padre
: Integer;
Entrada : Input_Window_Type:=Input_Window("Nombres");
begin
Create_Entry(Entrada,"Cual es tu nombre?: ","");
Create_Entry(Entrada,"Como se llama tu padre?: ","");
Wait(Entrada,"Teclea datos y pulsa OK");
Get_Line(Entrada,"Cual es tu nombre?: ",Tu_Nombre,N_Nombre);
Get_Line(Entrada,"Como se llama tu padre?: ",Tu_Padre,N_Padre);
Put_Line(Entrada,"El padre de "&Tu_Nombre(1..N_Nombre)&
" es "&Tu_Padre(1..N_Padre));
Wait(Entrada,"");
end Nombres;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
28
UNIVERSIDAD
DE CANTABRIA
En este ejemplo usamos una ventana de la librería Win_IO del tipo Input_Window_Type, que permite leer
datos de teclado.
Cada dato se lee de una entrada ("entry") que hay que crear con Create_Entry. Se identifica mediante
una etiqueta (un string) que se pasa como parámetro
Para leer un texto de una entrada se usa Get_Line, que funciona de modo análogo al Get_Line de
Ada.Text_IO
Se puede escribir en una zona de la ventana Input_Window_Type mediante Put_Line, que funciona
también de modo análogo al de Ada.Text_IO.
Para esperar a que el usuario teclee o pueda ver el resultado hay que invocar a Wait. En esta llamada se
pasa un texto que se muestra también en la ventana.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.4. Expresiones
29
UNIVERSIDAD
DE CANTABRIA
Permiten transformar datos para obtener un resultado
Se construyen con
• operadores
- dependen del tipo de dato
- se pueden definir por el usuario
- los hay binarios (dos operandos) y unarios (un operando)
• operandos
- variables
- constantes
- funciones
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
30
Operadores aritméticos
UNIVERSIDAD
DE CANTABRIA
Operan con datos numéricos de un tipo concreto y obtienen datos
del mismo tipo.
Operador
Tipo
Operación
Operandos(s)
Resultado
+
-
binario
binario
suma
resta
numérico
numérico
el mismo
el mismo
+
-
unario
unario
identidad
negación
numérico
numérico
el mismo
el mismo
*
/
mod
rem
binario
binario
binario
binario
multiplicación
división
módulo
resto
numérico
numérico
Entero
Entero
el mismo
el mismo
Entero
Entero
**
**
abs
binario
binario
unario
elevar a
elevar a
valor absoluto
Entero, Entero >0
Real, Entero
numérico
Entero
Real
el mismo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
31
Notas:
UNIVERSIDAD
DE CANTABRIA
El operador de elevar a, **, con datos de tipo real está definido en otro módulo que veremos más adelante
El operador unario + no hace nada, pero se ofrece por simetría y porque se puede redefinir, como veremos
más adelante
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
32
Operadores relacionales
UNIVERSIDAD
DE CANTABRIA
Permiten comparar dos datos del mismo tipo y dar como resultado
un booleano
Operador
=
/=
<
<=
>
>=
Tipo
binario
binario
binario
binario
binario
binario
Operación
igual a
distinto de
menor que
menor o igual que
mayor que
mayor o igual que
Operandos(s)
cualquiera no limitado
cualquiera no limitado
escalar o string
escalar o string
escalar o string
escalar o string
Resultado
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean
Los tipos escalares son los discretos y los números reales
Los tipos discretos son los enteros, caracteres, booleanos y
enumerados
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
33
Notas:
UNIVERSIDAD
DE CANTABRIA
Observar que el operador de comparación de igualdad es =
• esto es diferente de lo usado en los lenguajes C, C++ o Java, que usan ==
Veremos más adelante que la asignación, que usa el símbolo := no es un operador en Ada
• en C, C++, y Java la asignación usa el símbolo = y es un operador, lo que quiere decir que se puede
usar dentro de expresiones más complejas, incluyendo varias asignaciones en la misma expresión
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
34
Operadores lógicos
UNIVERSIDAD
DE CANTABRIA
Permiten trabajar con valores lógicos (booleanos) y obtener
nuevos valores lógicos
Operador
Tipo
Operación
Operandos(s)
Resultado
and
or
xor
binario
binario
binario
y
o inclusivo
o exclusivo
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean
not
unario
negación
Boolean
Boolean
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
35
Operadores lógicos (cont.)
UNIVERSIDAD
DE CANTABRIA
Tablas de verdad:
Operando
Izquierdo
Operando
Derecho
And
Or
Xor
false
false
false
false
false
false
true
false
true
true
true
false
false
true
true
true
true
true
true
false
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
36
Operador de concatenación
UNIVERSIDAD
DE CANTABRIA
Trabaja con dos strings y produce un nuevo string que contiene
los caracteres del primero, y a continuación los del segundo
Operador
&
Tipo
Operación
binario
concatenación
Operandos(s)
Strings, o string y carácter
Resultado
String
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
37
Precedencia de los operadores, de
menor a mayor
UNIVERSIDAD
DE CANTABRIA
La precedencia puede modificarse con el uso de paréntesis.
Operador
Operación
Operandos(s)
Resultado
and
or
xor
y
o inclusivo
o exclusivo
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean
=
/=
<
<=
>
>=
igual a
distinto de
menor que
menor o igual que
mayor que
mayor o igual que
cualquiera no limitado
cualquiera no limitado
escalar o string
escalar o string
escalar o string
escalar o string
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean
&
Concatenación
Strings,string y carácter String
+
-
suma
resta
numérico
numérico
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
el mismo
el mismo
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
38
Precedencia de los operadores, de
menor a mayor (cont.)
Operador
Operación
Operandos(s)
UNIVERSIDAD
DE CANTABRIA
Resultado
+
-
identidad
negación
numérico
numérico
el mismo
el mismo
*
multiplicación
/
división
mod
rem
módulo
resto
Entero
Real
Entero
Real
Entero
Entero
Entero
Real
Entero
Real
Entero
Entero
**
**
not
abs
exponenciación
“
negación
valor absoluto
Entero, Entero no negativo
Real, Entero
Boolean
numérico
Entero
Real
Boolean
el mismo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
39
Notas:
UNIVERSIDAD
DE CANTABRIA
La precedencia de los operadores nos permite saber qué operaciones se hacen primero y cuáles después,
si aparecen varios operadores en la misma expresión.
Por ejemplo:
• 3+x*5+y hace primero el producto de x*5 y luego las sumas
La precedencia puede modificarse con paréntesis
• Por ejemplo (3+x)*(5+y) hace primero lo que está dentro de los paréntesis (las sumas) y luego el
producto
Sólo pueden usarse paréntesis (), no corchetes [] ni llaves {}, ni paréntesis angulares <>
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Comprobación de inclusión
40
UNIVERSIDAD
DE CANTABRIA
En una expresión se puede usar la comprobación de inclusión
para obtener un booleano:
valor in rango
valor in tipo
Un rango se puede expresar como un intervalo de valores
escalares (números, caracteres, enumerados, booleanos):
valor1 .. valor2
Por ejemplo, para comprobar si a pertenece al intervalo [3,14]
a in 3..14
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplos de expresiones
41
UNIVERSIDAD
DE CANTABRIA
aritméticas
X+3.0+Y*12.4
Y**N+8.0
relacionales
X>3.0
N=28 -- compara N con 28. No confundir con la asignación
booleanas
X>3.0 and X<8.0 -- true si X es mayor que 3 y menor que 8
inclusión
A in 1..20
-- true o false según A esté o no entre 1 y 20
concatenación
Mi_Nombre&” texto añadido” -- el resultado es un nuevo string
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
42
Notas:
UNIVERSIDAD
DE CANTABRIA
Observar que los resultados de las operaciones relacionales son booleanos
Las operaciones relacionales no se pueden agrupar de dos en dos
• Por ejemplo, en matemáticas se puede escribir 1 < a < 3 para comprobar si a ∈ ( 1, 3 )
• En programación el computador haría primero 1<a, obteniendo un booleano (por ejemplo, true);
luego compararía true<3, lo que no tiene sentido
• Para escribir a ∈ ( 1, 3 ) debemos usar dos expresiones relacionales unidas con un operador lógico:
1<a and a<3
• Podríamos usar la comprobación de inclusión si los límites del intervalo estuviesen incluidos en él. Así
para a ∈ [ 1, 3 ] : a in 1.0..3.0
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Instrucción de asignación
43
UNIVERSIDAD
DE CANTABRIA
La asignación permite dar valor a una variable
• en Ada es una instrucción, de modo que no se pueden mezclar
varias asignaciones en la misma expresión
• esto contribuye a la sencillez, y a cometer menos errores
Sintaxis
variable := expresión;
Ejemplos
I, J : Integer;
X, Y : Float;
...
I:=3+J;
J:=3;
X:=Y;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
44
UNIVERSIDAD
DE CANTABRIA
Observar que la asignación borra el valor anteriormente guardado en la variable
Observar que la variable cuyo valor se cambia se pone a la izquierda, no a la derecha
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
45
Tipificación estricta
UNIVERSIDAD
DE CANTABRIA
No podemos mezclar datos de distinto tipo:
I, J : Integer;
X, Y : Float;
I+3*J -- expresión entera
I+X
-- expresión ilegal
Conversión de tipos: Tipo(valor)
I+Integer(X)
Float(I)+X
-- expresión entera
-- expresión real
Ojo con las operaciones de división
3/10
3.0/10.0
-- vale cero (división entera)
-- vale 0.3
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Expresiones con mod y rem:
46
UNIVERSIDAD
DE CANTABRIA
Con mod el resultado tiene el signo del denominador
Con rem el resultado es el resto de la división entera (que
redondea por debajo)
Ejemplos:
37
-37
37
-37
37
-37
37
-37
mod
mod
rem
rem
mod
mod
rem
rem
10
10
10
10
-10
-10
-10
-10
=
=
=
=
=
=
=
=
7
3
7
-7
-3
-7
7
-7
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de un programa con
expresiones
47
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Ada.Integer_Text_IO,Ada.Float_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO, Ada.Float_Text_IO;
procedure Nota_Media is
Nota1,Nota2,Nota3,Nota_Media : Integer;
begin
Put("Nota del primer trimestre: ");
Get(Nota1); Skip_Line;
Put("Nota del segundo trimestre: ");
Get(Nota2); Skip_Line;
Put("Nota del tercer trimestre: ");
Get(Nota3); Skip_Line;
Nota_Media := (Nota1+Nota2+Nota3)/3;
Put("Nota Media : ");
Put(Nota_Media); New_Line;
Put("Nota Media (otra) : ");
Put(Float(Nota1+Nota2+Nota3)/3.0);
New_Line;
end Nota_Media;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
48
Notas:
UNIVERSIDAD
DE CANTABRIA
El programa usa el módulo Ada.Integer_Text_IO para I/O de enteros y Ada.Float_Text_IO para I/
O de números reales
El programa declara cuatro variables enteras: Nota1, Nota2, Nota3, Nota_Media
Después lee las tres notas por teclado, usando la operación Get de Ada.Integer_Text_IO:
• La operación lee un número entero de una línea tecleada, y lo mete en la variable indicada entre
paréntesis
• Es importante después del Get invocar a Skip_Line para consumir el salto de línea que se usa para
separar un dato del siguiente
• Es importante antes del Get escribir en la pantalla lo que se espera del usuario, para que éste sepa
lo que tiene que hacer
Recomendación: Acordarse de hacer un Skip_Line por cada línea leída (no escrita) del teclado. Si nos
olvidamos alguno, pueden ocurrir comportamientos extraños.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas: (cont.)
49
UNIVERSIDAD
DE CANTABRIA
Una vez leídas las notas se calcula la media entera y se muestra con la operación Put de
Ada.Integer_Text_IO
• después del Put se invoca a New_Line para escribir en la pantalla un salto de línea
Nota: No confundir Skip_Line con New_Line. El primero afecta al teclado (e indirectamente a la pantalla
pues todo lo que se teclea aparece en ella), y el segundo exclusivamente a la pantalla.
Después se calcula la media real y se pone en pantalla con la operación Put de Ada.Float_Text_IO
• Observar que para calcular la media real hay que convertir la suma de las notas al tipo Float
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con el atributo ’IMAGE
50
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Ada.Integer_Text_IO;
use Ada.Text_IO,Ada.Integer_Text_IO;
procedure Nota_Media is
Nota1,Nota2,Nota3,Nota_Media : Integer;
begin
Put("Nota del primer trimestre: ");
Get(Nota1); Skip_Line;
Put("Nota del segundo trimestre: ");
Get(Nota2); Skip_Line;
Put("Nota del tercer trimestre: ");
Get(Nota3); Skip_Line;
Nota_Media := (Nota1+Nota2+Nota3)/3;
Put_Line("Nota Media : "&Integer’Image(Nota_Media));
Put_Line("Nota Media (otra) : "&
Float’Image(Float(Nota1+Nota2+Nota3)/3.0));
end Nota_Media;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
51
Notas:
UNIVERSIDAD
DE CANTABRIA
En este caso la escritura en pantalla se hace exclusivamente con la operación Put_Line de
Ada.Text_IO
• se usa el atributo ’Image para convertir números a texto, y la concatenación de strings para crear un
único String que se imprime con Put_Line
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas
52
UNIVERSIDAD
DE CANTABRIA
with Input_Windows, Output_Windows;
use Input_Windows, Output_Windows;
procedure Nota_Media is
Nota1,Nota2,Nota3,Nota_Media : Integer;
Entrada : Input_Window_Type;
Salida : Output_Window_Type;
begin
-- lectura de datos
Entrada:=Input_Window("Nota Media");
Create_Entry(Entrada,"Nota del primer trimestre: ",0);
Create_Entry(Entrada,"Nota del segundo trimestre: ",0);
Create_Entry(Entrada,"Nota del tercer trimestre: ",0);
Wait(Entrada,"Introduce datos");
Get(Entrada,"Nota del primer trimestre: ",Nota1);
Get(Entrada,"Nota del segundo trimestre: ",Nota2);
Get(Entrada,"Nota del tercer trimestre: ",Nota3);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas (cont.)
53
UNIVERSIDAD
DE CANTABRIA
-- escribir resultados
Salida:=Output_Window("Nota Media");
Nota_Media := (Nota1+Nota2+Nota3)/3;
Create_Box(Salida,"Nota Media : ",Nota_Media);
Create_Box(Salida,"Nota Media (otra) : ",
Float(Nota1+Nota2+Nota3)/3.0);
Wait(Salida);
end Nota_Media;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
54
Notas:
UNIVERSIDAD
DE CANTABRIA
En esta versión del ejemplo usamos una ventana del tipo Input_Window_Type para leer de teclado, y
otra del tipo Output_Window_Type para escribir los resultados
En la ventana del tipo Input_Window_Type (ver ejemplo anterior usando esta ventana) creamos tres
entradas para leer de ellas las tres notas
• Para leer enteros usamos la operación Get, siempre después de haber esperado con Wait a que el
usuario tenga tiempo de teclear
La ventana del tipo Output_Window_Type se crea invocando a Output_Window con el título de la
ventana
• Para escribir en ella debemos crear "cajas" llamando a Create_Box, cada una con una etiqueta de
texto y un valor
• Luego hay que llamar a la operación Wait para dar oportunidad al usuario de ver los datos.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
A destacar
55
UNIVERSIDAD
DE CANTABRIA
Uso de Put y Get para enteros y reales
Uso del Skip_Line detrás de cada "Get" en el teclado (pero no
detrás de Get_Line)
• Aunque a veces no es necesario, otras sí (p.e., cuando después
hay un Get_Line)
• Es conveniente acostumbrarse a ponerlo siempre
También es cómodo usar el atributo:
• ’Image al escribir
• ’Value al leer
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.5. Instrucciones de control
56
UNIVERSIDAD
DE CANTABRIA
Permiten modificar el flujo de ejecución del programa
Son:
• Instrucciones condicionales
- if (simple, doble, múltiple)
- case: condición discreta (múltiple)
• Instrucciones de lazo (loop)
- for: número de veces conocido
- while: condición de salida al principio
- otras condiciones de salida (exit)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
57
1.5.1. Instrucción condicional lógica
(if)
UNIVERSIDAD
DE CANTABRIA
Forma simple:
if exp_logica then
instrucciones;
end if;
Forma doble:
if exp_logica then
instrucciones;
else
instrucciones;
end if;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
58
UNIVERSIDAD
DE CANTABRIA
Esta instrucción permite tomar decisiones en base a un valor booleano
Si el booleano es cierto se ejecutan las instrucciones contenidas dentro de la instrucción if
Si es falso, se ejecutan las instrucciones contenidas en la parte else, o nada si ésta no existe
Al acabar, se continúa con la siguiente instrucción puesta a continuación del if
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Instrucción condicional lógica (cont.)
59
UNIVERSIDAD
DE CANTABRIA
Forma múltiple:
if exp_logica then
instrucciones;
elsif exp_logica then
instrucciones;
elsif exp_logica then
instrucciones
...
else
instrucciones;
end if;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
60
Notas:
UNIVERSIDAD
DE CANTABRIA
En la forma múltiple, la decisión de qué instrucciones ejecutar se basa en múltiples valores booleanos.
• Se evalúan en el orden en que aparecen
• En cuanto uno de ellos es verdad, se ejecutan las instrucciones colocadas inmediatamente a
continuación y la instrucción if termina
• Si ninguno es verdad se ejecuta la parte else, si existe
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: cálculo del máximo de A,B y
C:
61
UNIVERSIDAD
DE CANTABRIA
if A>B then
max:=A;
else
max:=B;
end if;
if max<C then
max:=C;
end if;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
62
UNIVERSIDAD
DE CANTABRIA
En este ejemplo comparamos dos datos, A y B, para quedarnos con el mayor de los dos en la variable max.
Posteriormente comparamos esta variable con C para quedarnos con la más grande.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
63
Nota: Evaluación condicional de
expresiones booleanas
UNIVERSIDAD
DE CANTABRIA
Las expresiones lógicas normales evalúan las dos partes de la
expresión
if j>0 and i/j>k then ...
Posibilidad de error si j=0. Solución para evaluar la segunda parte
sólo si se cumple la primera:
if j>0 and then i/j>k then ...
Lo mismo se puede hacer con la operación or:
if j>0 or else abs(j)<3 then ...
La evaluación condicional es más eficiente
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.5.2. Instrucción condicional
discreta (case)
64
UNIVERSIDAD
DE CANTABRIA
Para decisiones que dependen de una expresión discreta se usa la
instrucción case
• más elegante
• habitualmente más eficiente
Las expresiones discretas son
-
enteros
caracteres
booleanos
enumerados
pero no los números reales.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Instrucción case
65
UNIVERSIDAD
DE CANTABRIA
case exp_discreta is
when valor1 =>
instrucciones;
when valor2 =>
instrucciones;
when valor3 | valor4 | valor5 =>
instrucciones;
when valor6..valor7 =>
instrucciones;
when others =>
instrucciones;
end case;
Requisitos:
• La cláusula others es opcional, pero si no aparece, es
obligatorio cubrir todos los posibles valores
• Si no se desea hacer nada poner la instrucción null
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
66
Notas:
UNIVERSIDAD
DE CANTABRIA
La instrucción case evalúa la expresión discreta y ejecuta las instrucciones que corresponden a su valor.
Es equivalente al switch de Java/C, pero más flexible
Observar que es posible agrupar varios valores, o incluso rangos de valores, en el mismo caso
• los casos deben ser disjuntos
Si ninguno de los valores corresponde, se ejecutan las instrucciones en la cláusula others
• La cláusula others es opcional, pero si no se pone es obligatorio haber cubierto todos los posibles
casos
Las instrucciones de cada caso son obligatorias. Si no se desea hacer nada hay que decirlo explícitamente
poniendo una instrucción null, que no hace nada.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Poner la nota media con
letra:
67
UNIVERSIDAD
DE CANTABRIA
Nota_Media : Integer:=...;
case Nota_Media is
when 0..4
=> Put_Line("Suspenso");
when 5..6
=> Put_Line("Aprobado");
when 7..8
=> Put_Line("Notable");
when 9..10 => Put_Line("Sobresaliente");
when others => Put_Line("Error");
end case;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
El mismo ejemplo si la nota es un real:
68
UNIVERSIDAD
DE CANTABRIA
Nota_Media : Float:=...;
if Nota_Media<0.0 then
Put_Line("Error");
elsif Nota_Media<5.0 then
Put_Line("Suspenso");
elsif Nota_Media<7.0 then
Put_Line("Aprobado");
elsif Nota_Media<9.0 then
Put_Line("Notable");
elsif Nota_Media<=10.0 then
Put_Line("Sobresaliente");
else
Put_Line("Error");
end if;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
69
1.5.3. Instrucciones de lazo o bucle
UNIVERSIDAD
DE CANTABRIA
Permiten repetir un conjunto de instrucciones
Hay varias instrucciones de lazo, según el número de veces que se
quiera hacer el lazo:
• indefinido: lazo infinito
• número máximo de veces conocido al ejecutar: lazo con variable
de control
• número máximo de veces no conocido:
- el lazo se hace 0 a más veces: condición de permanencia al
principio
- el lazo se hace 1 o más veces: condición de salida al final.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
A. Lazo infinito
70
UNIVERSIDAD
DE CANTABRIA
Ejemplo:
loop
Put_Line("No puedo parar");
-- más instrucciones
end loop;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
B. Lazo con variable de control (for)
71
UNIVERSIDAD
DE CANTABRIA
Una variable discreta toma todos los valores de un rango:
for var in rango loop
instrucciones;
end loop;
El rango se escribe de una de las siguientes maneras:
valor_inicial..valor_final
tipo
tipo range valor_inicial..valor_final
Comentarios:
- La variable se declara en la instrucción y sólo existe durante el lazo
- Toma los valores del rango: [inicial,final], uno por uno
- No se puede cambiar su valor
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
72
B. Lazo con variable de control (cont.)
UNIVERSIDAD
DE CANTABRIA
Los valores se pueden recorrer en orden inverso:
for i in reverse rango loop
Ojo. No es lo mismo:
reverse 1..10
10..1
-- rango nulo !
Ejemplo: Suma de los 100 primeros números
Suma : Integer:=0;
for i in 1..100 loop
Suma:=Suma+i;
end loop;
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
C. Lazo con condición de permanencia
al principio (while)
73
UNIVERSIDAD
DE CANTABRIA
Sintaxis:
while exp_logica loop
instrucciones;
end loop;
Las instrucciones se ejecutan si la expresión lógica es true
Ejemplo: calcular cuántos números enteros pares hay que sumar,
empezando en uno, para superar el valor 100.
J: Integer:=0;
Suma : Integer:=0;
while Suma<=100 loop
J:=J+2;
Suma:=Suma+J;
end loop;
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
D. Lazo con condición de salida en
cualquier lugar
74
UNIVERSIDAD
DE CANTABRIA
Instrucciones exit:
exit;
-- salir del bucle incondicionalmente
exit when condicion; -- salir del bucle si se cumple la condicion
Ejemplo: Calcular la suma de la serie hasta que el término sumado
sea menor que 10-6, partiendo de un valor x=1.2
(x – 1) (x – 1) (x – 1)
- + ---------------+…
---------------- + --------------2
3
x
x
x
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
75
Ejemplo de lazo con condición de salida
al final
UNIVERSIDAD
DE CANTABRIA
X : Float:=1.2;
Suma : Float:=0.0;
-- elemento neutro de la suma
Termino : Float;
-- no requiere valor inicial
Potencia : Float:=1.0; -- elemento neutro del producto
loop
Potencia:=Potencia*X; -- es más eficiente "*" que "**"
Termino:=(X-1.0)/Potencia;
Suma:=Suma+Termino;
exit when Termino<1.0E-6;
end loop;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo con instrucciones
condicionales y de lazo:
76
UNIVERSIDAD
DE CANTABRIA
Calcular el máximo de un conjunto de valores reales introducidos
por teclado
Pseudocódigo:
maximo:=menor valor posible
Leer el número de valores
para i desde 1 hasta n
leer num
si num> maximo
maximo=num
fin si
fin para
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo con instrucciones
condicionales y de lazo
77
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Ada.Integer_Text_IO,Ada.Float_Text_IO;
use Ada.Text_IO;
use Ada.Integer_Text_IO;
use Ada.Float_Text_IO;
procedure Maximo is
Maximo
: Float :=Float'First;
X
: Float;
Num_Veces : Integer;
...
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
78
Ejemplo con instrucciones
condicionales y de lazo (cont.)
UNIVERSIDAD
DE CANTABRIA
begin
Put("Numero de valores: ");
Get(Num_Veces);
Skip_Line;
for I in 1..Num_Veces loop
Put("Valor : ");
Get(X);
Skip_Line;
if X>Maximo then
Maximo:=X;
end if;
end loop;
Put("El maximo es : ");
Put(Maximo);
New_Line;
end Maximo;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas
79
UNIVERSIDAD
DE CANTABRIA
with Input_Windows;
use Input_Windows;
procedure Maximo is
Maximo
X
Num_Veces
Entrada :
: Float :=Float'First;
: Float;
: Integer;
Input_Window_Type:=Input_Window("Maximo");
begin
Create_Entry(Entrada,"Numero de valores: ",0);
Wait(Entrada,"");
Get(Entrada,"Numero de valores: ",Num_Veces);
for I in 1..Num_Veces loop
Create_Entry(Entrada,"Valor : "&Integer'Image(I),0.0);
end loop;
Wait(Entrada,"");
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas (cont.)
80
UNIVERSIDAD
DE CANTABRIA
for I in 1..Num_Veces loop
Get(Entrada,"Valor : "&Integer'Image(I),X);
if X>Maximo then
Maximo:=X;
end if;
end loop;
Wait(Entrada,"El maximo es : "&Float'Image(Maximo));
end Maximo;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
81
Notas:
UNIVERSIDAD
DE CANTABRIA
En este ejemplo primero leemos de teclado el número de datos que el usuario desea introducir, y luego
creamos tantas entradas como datos se necesitan, para leer un dato de cada una.
Como las entradas deben tener etiquetas distintas, incluimos una parte numérica variable en las etiquetas
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
82
1.6. Tipos de datos
UNIVERSIDAD
DE CANTABRIA
Jerarquía de tipos:
Tipos
escalares
reales
discretos
enteros
compuestos
punteros
arrays
registros
enumerados
caracteres
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
booleanos
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Declaración de tipos:
83
UNIVERSIDAD
DE CANTABRIA
Formato:
type Nombre_Tipo is definicion;
Ojo: un tipo de datos no es un objeto de datos:
• no ocupa espacio en memoria
• es sólo una definición para usar más adelante al crear variables
y constantes
Concepto de subtipo: un tipo de datos puede tener subtipos, que
restringen el rango o la precisión del tipo
• Los datos de diferentes tipos no se pueden mezclar
• Pero podemos mezclar datos de diferente subtipo si son del
mismo tipo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
84
1.6.1. Tipos enteros
UNIVERSIDAD
DE CANTABRIA
Declaración:
type Nombre is range valor_inicial .. valor_final;
Subtipos enteros:
subtype Nombre is Tipo range valor_inicial .. valor_final;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: declaraciones de datos en un
prog. de nóminas:
85
UNIVERSIDAD
DE CANTABRIA
type Dinero is range 0..1_000_000; -- euros
type Sueldo_Director is range 0..100_000;
type Sueldo_Ingeniero is range 0..10_000;
type Sueldo_Becario
is range 0..500; --pobrecillo
D :
S_D
S_I
S_B
Dinero;
: Sueldo_Director;
: Sueldo_Ingeniero;
: Sueldo_Becario;
Para calcular la nómina si hay 1 director, 3 ingenieros y cuatro
becarios:
D:=S_D+3*S_I+4*S_B; -- mal, pues no se pueden meclar tipos
D:=Dinero(S_D)+3*Dinero(S_I)+4*Dinero(S_B); -- bien, pero largo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Uso de subtipos
86
UNIVERSIDAD
DE CANTABRIA
Puesto que los sueldos y el dinero son de la misma naturaleza, es
mejor usar subtipos:
type Dinero is range 0..1_000_000; -- euros
subtype Sueldo_Director is Dinero range 0..100_000;
subtype Sueldo_Ingeniero is Dinero range 0..10_000;
subtype Sueldo_Becario
is Dinero range 0..500;
D :
S_D
S_I
S_B
Dinero;
: Sueldo_Director;
: Sueldo_Ingeniero;
: Sueldo_Becario;
Y ahora para calcular la nómina:
D:=S_D+3*S_I+4*S_B; -- correcto, pues todos son del mismo tipo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
87
Más sobre subtipos
UNIVERSIDAD
DE CANTABRIA
¿Cuándo usar tipos o subtipos?
• usar subtipos para cosas de la misma naturaleza (p.e., sueldos)
• usar tipos para cosas de naturaleza diferente (p.e., sueldo y
temperatura)
Subtipos enteros predefinidos:
subtype Natural is Integer range 0..Integer’Last;
subtype Positive is Integer range 1..Integer’Last;
Subtipos anónimos
• es posible crear un subtipo anónimo directamente al crear una
variable:
I : Integer range 1..100; -- la variable I debe estar entre 1 y 100
-- y es del tipo Integer
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.6.2. Tipos reales
88
UNIVERSIDAD
DE CANTABRIA
Declaración:
type Tipo is digits n;
type Tipo is digits n range val1..val2;
Subtipos reales:
subtype Nombre is Tipo range val1..val2;
Ejemplo: un tipo equivalente al double de Java o C
type Real is digits 15;
Para mayor eficiencia, sólo conviene crear tipos reales soportados
directamente por el hardware
• por ejemplo, el tipo Real de arriba
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.6.3. Tipos enumerados
89
UNIVERSIDAD
DE CANTABRIA
Sus valores son identificadores. Evitan la necesidad de usar
"códigos".
type Color is (Rojo, Verde, Azul);
type Escuela is (Teleco, Caminos, Fisicas);
Los valores están ordenados, por el orden en que se escriben
Atributos más útiles de los tipos enumerados:
Tipo’First
Tipo’Last
Tipo’Succ(Valor)
Tipo’Pred(Valor)
Tipo’Pos(Valor)
Tipo’Val(Número)
Tipo’Image(Valor)
Tipo’Value(Texto)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
primer valor
último valor
sucesor: siguiente a Valor
predecesor
código numérico del Valor (empiezan en cero)
Valor enumerado correspondiente al número
Conversión a texto
Conversión de texto a enumerado
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
90
Entrada/salida de tipos escalares
UNIVERSIDAD
DE CANTABRIA
Ada.Text_IO contiene submódulos genéricos:
• los podemos especializar para leer o escribir datos de tipos
creados por nosotros
Poner en las declaraciones una (o varias) de estas líneas:
package Int_IO
is new Ada.Text_IO.Integer_IO(Mi_Tipo_Entero);
package F_IO
is new Ada.Text_IO.Float_IO(Mi_Tipo_real);
package Color_IO is new Ada.Text_IO.Enumeration_IO
(Mi_Tipo_Enumerado);
Esto crea los módulos Int_IO, F_IO, y Color_IO
• cada uno con operaciones Get y Put para leer o escribir,
respectivamente, datos de los tipos indicados
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Entrada/Salida de tipos escalares
(cont.)
91
UNIVERSIDAD
DE CANTABRIA
Podemos poner cláusulas use para estos módulos después de
crearlos.
use Color_IO;
C : Color;
...
Get(C);
Skip_Line;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo con tipos subrango y
enumerados
92
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO;
use Ada;
procedure Nota_Media_Enum is
type Nota_num is range 0..10;
type Nota_Letra is
(Suspenso,Aprobado,Notable,Sobresaliente);
package Nota_IO is new
Text_IO.Integer_IO(Nota_Num);
package Letra_IO is new
Text_IO.Enumeration_IO(Nota_Letra);
Nota1,Nota2,Nota3,Nota_Media : Nota_Num;
Nota_Final : Nota_Letra;
begin
Text_IO.Put("Nota del primer trimestre: ");
Nota_IO.Get(Nota1);
Text_IO.Skip_Line;
Text_IO.Put("Nota del segundo trimestre: ");
Nota_IO.Get(Nota2);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
93
Ejemplo con tipos subrango y
enumerados (cont.)
UNIVERSIDAD
DE CANTABRIA
Text_IO.Skip_Line;
Text_IO.Put("Nota del tercer trimestre: ");
Nota_IO.Get(Nota3);
Text_IO.Skip_Line;
Nota_Media := (Nota1+Nota2+Nota3)/3;
Text_IO.Put("Nota Media : ");
Nota_IO.Put(Nota_Media);
Text_IO.New_Line;
case Nota_Media is
when 0..4 => Nota_Final:=Suspenso;
when 5..6 => Nota_Final:=Aprobado;
when 7..8 => Nota_Final:=Notable;
when 9..10 => Nota_Final:=Sobresaliente;
end case;
Text_IO.Put("Nota Final : ");
Letra_IO.Put(Nota_Final);
Text_IO.New_Line;
end Nota_Media_Enum;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas
94
UNIVERSIDAD
DE CANTABRIA
with Input_Windows, Output_Windows;
use Input_Windows, Output_Windows;
procedure Nota_Media_Enum is
type Nota_Num is range 0..10;
type Nota_Letra is
(Suspenso,Aprobado,Notable,Sobresaliente);
Nota1,Nota2,Nota3,Nota_Media : Nota_Num;
Nota_Final : Nota_Letra;
Entrada : Input_Window_Type;
Salida : Output_Window_Type;
begin
-- lectura de datos
Entrada:=Input_Window("Nota Media");
Create_Entry(Entrada,"Nota del primer trimestre: ",0);
Create_Entry(Entrada,"Nota del segundo trimestre: ",0);
Create_Entry(Entrada,"Nota del tercer trimestre: ",0);
Wait(Entrada,"Introduce datos");
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas (cont.)
95
UNIVERSIDAD
DE CANTABRIA
Get(Entrada,"Nota del primer trimestre: ",Integer(Nota1));
Get(Entrada,"Nota del segundo trimestre: ",Integer(Nota2));
Get(Entrada,"Nota del tercer trimestre: ",Integer(Nota3));
-- escribir resultados
Salida:=Output_Window("Nota Media");
Nota_Media := (Nota1+Nota2+Nota3)/3;
Create_Box(Salida,"Nota Media : ",Nota_Num'Image(Nota_Media));
case Nota_Media is
when 0..4 => Nota_Final:=Suspenso;
when 5..6 => Nota_Final:=Aprobado;
when 7..8 => Nota_Final:=Notable;
when 9..10 => Nota_Final:=Sobresaliente;
end case;
Create_Box(Salida,"Nota Final : ",
Nota_Letra'Image(Nota_Final));
Wait(Salida);
end Nota_Media_Enum;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
96
Notas:
UNIVERSIDAD
DE CANTABRIA
La operación Get de Input_Windows sólo admite datos del tipo String, Integer, o Float
• No admite datos del tipo Nota
• Por ello hemos hecho una conversión de las variables Nota1, Nota2, y Nota3 al tipo Integer
• Observar que esta conversión funciona en ambos sentidos (para obtener el valor de la variable, o para
asignarle valor a través de la llamada al procedimiento)
La operación Create_Box de Output_Windows sólo admite datos del tipo String, Integer, o Float
• Por ello hemos usado el atributo ’Image para convertir una nota a texto, y luego un enumerado a texto
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
A destacar
97
UNIVERSIDAD
DE CANTABRIA
Las cláusulas use permitirían reducir el texto
Los tipos subrango permiten detectar errores de rango de manera
automática
• por ejemplo si ponemos una nota menor que cero o mayor que
10
• más adelante aprenderemos a tratar estos errores
El tipo subrango permite omitir la cláusula others en la
instrucción case
• pues ya hemos cubierto todos los casos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.6.4. Arrays
98
UNIVERSIDAD
DE CANTABRIA
Permiten almacenar muchos datos del mismo tipo: tablas o listas
de valores, vectores, etc.
Pueden ser multidimensionales: matrices,...
Su tamaño no puede cambiar después de crearlo
Se identifican por un nombre y un rango de valores del índice que
debe ser discreto
Declaración:
type Nombre is array (rango) of Tipo_Elemento;
El rango no tiene por qué ser un número (puede ser un carácter o
un enumerado) ni necesita empezar en cero
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
99
Ejemplos:
UNIVERSIDAD
DE CANTABRIA
type Vector_3D is array (1..3) of Float;
type Meses is (Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio,
Agosto, Septiembre, Octubre, Noviembre, Diciembre);
type Num_Dias_Mes is array(Integer range 1..12) of Natural;
type Num_Dias is array(Meses) of Natural;
type Matriz is array (1..3,1..4) of Float;
subtype Hora is Integer range 0..23;
subtype Temp is Float range -273.0..1000.0;
type Tabla_Temperaturas is array (Hora,Meses) of Temp;
Los rangos no tienen por qué ser estáticos:
N : Integer := valor;
type Bool is array (1..N) of Boolean;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
100
UNIVERSIDAD
DE CANTABRIA
Las variables del tipo:
• Vector_3D tendrán tres números reales, cuyos índices serán 1,2,3
• Num_Dias_Mes tendrán 12 enteros no negativos, con índices de 1 a 12
• Num_Dias tendrán 12 enteros no negativos, correspondientes a los meses de Enero, Febrero, ... ,
Diciembre
• Matriz son arrays bidimensionales de 12 números reales. El primer índice (que puede indicar, por
ejemplo, las filas) tiene 3 valores: 1,2,3. El segundo índice (que puede indicar, por ejemplo, las
columnas) tiene 4 valores: 1,2,3,4
• Tabla_Temperaturas tendrán 24x12=288 valores reales del tipo Temp, uno por cada combinación
hora-mes.
• Bool tendrán N valores booleanos, siendo N un valor conocido en tiempo de ejecución. Eso sí, una
vez creado el tipo, su tamaño ya no cambia, aunque N cambie.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Uso del array:
101
UNIVERSIDAD
DE CANTABRIA
• Completo: por su nombre
• Un elemento: nombre(indice)
• Una rodaja: nombre(indice1..indice2)
Ejemplos:
V1, V2 : Vector_3D;
M : Matriz;
Dias : Num_Dias;
T : Tabla_Temperaturas;
B : array (1..100) of Float; -- Array de tipo anónimo
Contactos : Bool;
...
V1(1):=3.0+V2(3);
M(2,3):=M(1,1)*2.0 + B(12);
Dias(Enero):=31;
T(20,Febrero):=23.1;
V2:=V1;
V1(1..2):=V2(2..3);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
102
Notas:
UNIVERSIDAD
DE CANTABRIA
Declaraciones
• V1 y V2 son arrays de 3 números reales
• M es un array bidimensional de 12 números reales
• Dias es un array de 12 enteros no negativos
• T es un array de 288 valores reales del tipo Temp
• B es un array de 100 números reales, numerados de 1..100. Este ejemplo muestra que se puede crear
un array con un tipo anónimo, directamente al crear la variable
- Hay que tener cuidado, pues los tipos anónimos son incompatibles, aunque se definan igual. Por
ejemplo si creamos B2 : array (1..100) of Float, no podremos mezclar B y B2
• Contactos es un array de N valores booleanos
Instrucciones
• Las cuatro primeras instrucciones muestran cómo usar una casilla individual del array
• La instrucción V2:=V1 copia todas las casillas de V1 en V2
• La instrucción V1(1..2):=V2(2..3)copia las casillas 2 a 3 de V2 en las casillas 1 a 2 de V1.
- El tamaño de ambos fragmentos debe coincidir
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Atributos de arrays:
103
UNIVERSIDAD
DE CANTABRIA
Tipo’Range o Array’Range: es el rango de valores
for i in V1’Range loop
V1(i):=0.0; -- la variable i toma sucesivamente todos
end loop;
-- los valores del índice
Tipo’Length o Array’Length: indica la longitud del array (el
número de elementos)
for i in 1..V1’Length-1 loop
V1(i):=0.0; -- la variable i toma sucesivamente todos
end loop;
-- los índices desde el 1 hasta el penúltimo
Tipo’First o Array’First: es el primer índice
Tipo’Last o Array’Last: es el último índice
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Literales de array
104
UNIVERSIDAD
DE CANTABRIA
Permiten expresar arrays a partir de todos los valores
V1:=(0.0, 3.2, 1.2);
Dias:=(31,28,31,30,31,30,31,31,30,31,30,31);
O agrupándolos por rangos del índice
Contactos:=Bool’(1..3 => True, 4 => False,
5|8 => True, others =>False);
M:= Matriz’(1..3 => (1..3 => 0.0));
Dias:=Num_Dias’(febrero =>28,
abril|junio|septiembre|noviembre =>30,
others =>31);
Funciona también con rodajas de arrays
B(1..4):=(0.0,1.0,2.0,3.0);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
105
Ejemplo de programa que usa vectores
UNIVERSIDAD
DE CANTABRIA
Cálculo del producto escalar de dos vectores de dimensión
definible por el usuario:
• Modalidad 1: usar parte de un array grande
- una variable entera almacena el tamaño útil
• Modalidad 2: crear el array del tamaño justo
• Modalidad 3: usar arrays no restringidos
- el tamaño no va en el tipo sino que se expresa al crear la variable
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo versión 1: arrays de
dimensión fija
106
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Ada.Integer_Text_IO,Ada.Float_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO, Ada.Float_Text_IO;
procedure Producto is
Dimension_Max : constant Integer := 100;
type Vector is array (1..Dimension_Max) of Float;
V1,V2
: Vector;
N
: Integer range 1..Dimension_Max;
Prod_Escalar : Float:=0.0;
begin
Put("Introduce dimension : ");
Get(N);
Skip_Line;
Put_Line("Vector V1:");
for I in 1..N loop
Put("Introduce componente ");
Put(I); Put(": ");
Get(V1(I)); Skip_Line;
end loop;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo v1: arrays de dimensión fija
(cont.)
107
UNIVERSIDAD
DE CANTABRIA
Put_Line("Vector V2:");
for I in 1..N loop
Put("Introduce componente ");
Put(I);
Put(": ");
Get(V2(I));
Skip_Line;
end loop;
for I in 1..N loop
Prod_Escalar:=Prod_Escalar + V1(I)*V2(I);
end loop;
Put("El producto escalar es : ");
Put(Prod_Escalar);
New_Line;
end Producto;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
108
Ejemplo versión 2: arrays de tamaño
variable
UNIVERSIDAD
DE CANTABRIA
Modalidad 2: declarar los arrays del tamaño justo
Usar para ello la instrucción declare, que se puede poner junto a
otras instrucciones y permite declarar nuevas variables, tipos, ...
leer N;
declare
v1,v2 : array(1..N) of Float;
begin
...-- uso de v1 y v2
end;
Las declaraciones hechas en un declare sólo se pueden usar
hasta el correspondiente end
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo v2: arrays de dimensión
variable
109
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_Io,Ada.Integer_Text_Io,Ada.Float_Text_Io;
use Ada.Text_Io, Ada.Integer_Text_Io, Ada.Float_Text_Io;
procedure Producto_Variable is
N
: Positive;
Prod_Escalar : Float:=0.0;
begin
Put("Introduce dimension : ");
Get(N);
Skip_Line;
declare
type Vector is array (1..N) of Float;
V1,V2 : Vector;
begin
Put_Line("Vector V1:");
for I in V1’range loop
Put("Introduce componente ");
Put(I);
Put(": ");
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo v2: arrays de dimensión
variable (cont.)
110
UNIVERSIDAD
DE CANTABRIA
Get(V1(I)); Skip_Line;
end loop;
Put_Line("Vector V2:");
for I in V2’range loop
Put("Introduce componente ");
Put(I);
Put(": ");
Get(V2(I)); Skip_Line;
end loop;
for I in V1’range loop
Prod_Escalar:=Prod_Escalar + V1(I)*V2(I);
end loop;
Put("El producto escalar es : ");
Put(Prod_Escalar);
New_Line;
end;
end Producto_Variable;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
111
Arrays no restringidos
UNIVERSIDAD
DE CANTABRIA
El tamaño se deja indeterminado, y se define al declarar la variable
type Vector is array (Integer range <>) of Float;
V1 : Vector(1..100);
V2 : Vector(1..200);
Modalidad 3: usar un tipo irrestringido y declarar los arrays del
tamaño justo
type Vector is array(Integer range <>) of Float;
leer N
declare
v1,v2 : Vector(1..N);
begin
...-- uso de v1 y v2
end;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo v3: arrays no restringidos
112
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Ada.Integer_Text_IO,Ada.Float_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO, Ada.Float_Text_IO;
procedure Producto_Irrestringido is
type Vector is array (Positive range <>) of Float;
N
: Positive;
Prod_Escalar : Float:=0.0;
begin
Put("Introduce dimension : ");
Get(N);
Skip_Line;
declare
V1,V2
: Vector(1..N);
begin
Put_Line("Vector V1:");
for I in V1’range loop
Put("Introduce componente ");
Put(I);
Put(": ");
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo v3: arrays no restringidos
113
UNIVERSIDAD
DE CANTABRIA
Get(V1(I));
Skip_Line;
end loop;
Put_Line("Vector V2:");
for I in V2’range loop
Put("Introduce componente ");
Put(I);
Put(": ");
Get(V2(I)); Skip_Line;
end loop;
for I in V1’range loop
Prod_Escalar:=Prod_Escalar + V1(I)*V2(I);
end loop;
Put("El producto escalar es : ");
Put(Prod_Escalar);
New_Line;
end;
end Producto_Irrestringido;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
114
Mismo ejemplo con ventanas
UNIVERSIDAD
DE CANTABRIA
with Input_Windows, Output_Windows;
use Input_Windows, Output_Windows;
procedure Producto_Irrestringido is
type Vector is array (Positive range <>) of Float;
N
: Positive;
Prod_Escalar : Float:=0.0;
Entrada : Input_Window_Type;
Salida : Output_Window_Type;
begin
Entrada:=Input_Window("Producto Escalar");
Create_Entry(Entrada,"Introduce dimension : ",0);
Wait(Entrada,"");
Get(Entrada,"Introduce dimension : ",N);
declare
V1,V2 : Vector(1..N);
begin
-- Crea las entradas
for I in V1’range loop
Create_Entry(Entrada,"V("&Integer’Image(I)&")",0.0);
end loop;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Mismo ejemplo con ventanas (cont.)
115
UNIVERSIDAD
DE CANTABRIA
-- lee V1
Wait(Entrada,"Introduce Vector V1");
for I in V1’range loop
Get(Entrada,"V("&Integer’Image(I)&")",V1(I));
end loop;
-- lee V2
Wait(Entrada,"Introduce Vector V2");
for I in V2’range loop
Get(Entrada,"V("&Integer’Image(I)&")",V2(I));
end loop;
-- calcula resultado
for I in V1’range loop
Prod_Escalar:=Prod_Escalar + V1(I)*V2(I);
end loop;
-- escribe resultado
Salida:=Output_Window("Producto Escalar");
Create_Box(Salida,"El producto escalar es : ",Prod_Escalar);
Wait(Salida);
end;
end Producto_Irrestringido;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.6.5. Registros
116
UNIVERSIDAD
DE CANTABRIA
Permiten agrupar datos de diferentes tipos, similarmente a los
atributos de un objeto en C++ o Java
• veremos más adelante cómo asociarles métodos
Se identifican por el nombre del registro y unos campos
Declaración:
type Nombre_Tipo is record
nombre_campo1 : tipo_campo1;
nombre_campo2 : tipo_campo2;
...
end record;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
117
Registros (cont.)
UNIVERSIDAD
DE CANTABRIA
Ejemplo
type Tipo_Escuela is (Teleco, Ciencias, Caminos);
type Alumno is record
nombre : String(1..20);
n_nombre : Integer range 0..20;
num_Telefono : String (1..9);
Escuela : Tipo_Escuela:=Teleco;
end record;
Los campos pueden tener valor inicial
• que será luego asignado a cada variable que se cree de ese tipo
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
Uso de registros
118
UNIVERSIDAD
DE CANTABRIA
• Completos: por su nombre
• Por componentes: nombre.campo
Ejemplos:
A1,A2 : Alumno;
...
A2.Nombre:="Pepe
A1:=A2;
A2.Escuela:=Ciencias;
"; -- 20 caracteres
Literales de registro
A1:=("Pedro
A2:=(Nombre
N_Nombre
Telefono
Escuela
=>
=>
=>
=>
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
",5,"942201020",Caminos);
"Juan
",
4,
"942333333",
Teleco);
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
119
UNIVERSIDAD
DE CANTABRIA
En los ejemplos anteriores
• A1 y A2 son dos registros del tipo Alumno
• A2.Nombre es el campo Nombre de A2
• Los registros permiten la asignación: se copian todos los campos
En los literales de registro hay dos formatos:
• Poner los valores de los campos, separados por comas (deben ir en el mismo orden)
• Poner delante del valor de cada campo su nombre y una flecha =>; en este formato los campos se
pueden dar en el orden que se prefiera
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
120
Ejemplo: Diagrama estadístico de
barras
UNIVERSIDAD
DE CANTABRIA
Se desea hacer un programa que haga un gráfico de barras de
varios valores medidos, caracterizados cada uno por un valor
máximo y uno mínimo
• El número de datos (y de barras) es variable y el máximo es 20
Para cada dato hay que poder expresar el color en que se pinta la
barra de máximo y la de mínimo, así como una etiqueta de 3
caracteres
• esta información se guarda en un registro por dato, junto a los
valores máximo y mínimo
Los registros se guardan en un array, ocupando sus primeras
posiciones. Una variable entera indica cuántos datos hay. Ambos
(array y entero) se guardan en otro registro
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
121
Ejemplo: Diagrama estadístico de
barras (cont.)
UNIVERSIDAD
DE CANTABRIA
Datos_Estadistica
Lista_Datos
1 Max
Min
1.0
Max
Min
2.0
2
Max
Min
4.0
3
Max
Min
3.3
4
0.5
0.3
Rojo
Color_Max
Color_Min
Verde
Color_Max
Color_Min
Blanco
Azul
Etiqueta
Ene
Etiqueta
Feb
Etiqueta
Mar
Etiqueta
Abr
Num_Datos
2.5
0.7
Color_Max
Color_Min
Negro
Color_Max
Color_Min
4
Rosa
Rojo
Verde
...
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
122
UNIVERSIDAD
DE CANTABRIA
Datos_Estadística es un registro con los campos:
• Lista_Datos: es un array de registros del tipo Dato, de 20 casillas, numeradas de 1 a 20
• Num_Datos: es un entero que indica cuántos datos válidos hay almacenados en el momento actual
(desde el principio del array)
Dato es un registro con los siguientes campos
• Max: valor real que indica el valor máximo
• Min: valor real que indica el valor mínimo
• Color_Max: color con el que pintar la barra del máximo (un enumerado)
• Color_Min: color con el que pintar la barra del máximo (un enumerado)
• Etiqueta: texto de 3 caracteres
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
123
Ejemplo: Diagrama estadístico de
barras (cont.)
UNIVERSIDAD
DE CANTABRIA
with Graphics_Windows;
use Graphics_Windows;
procedure Estadistica is
Max_Datos : constant Integer:=20;
type Colores is (Negro, Blanco, Rojo, Verde, Azul,
Gris, Amarillo, Azul_Claro, Rosa);
type Dato is record
Max,Min : Float;
Color_Max,Color_Min : Colores;
Etiqueta : String(1..3):="
";
end record;
type Lista_Datos is array(1..Max_Datos) of Dato;
type Datos_Estadistica is record
Lista : Lista_Datos;
Num_Datos : Integer range 0..Max_Datos:=0;
end record;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Diagrama estadístico de
barras (cont.)
124
UNIVERSIDAD
DE CANTABRIA
Dat : Datos_Estadistica;
Grafico : Canvas_Type;
Ancho, Alto, Pos : Integer;
Factor, Maximo : Float;
Esp_Entre_Col : constant Integer:=2;
Transforma : array(Colores) of Color_Type:=
(Black, White, Red, Green, Blue, Gray, Yellow, Cyan, Magenta);
begin
-- Poner datos
Dat.Num_Datos:=8;
-- Uno por uno
Dat.Lista(1).Max:=20.0;
Dat.Lista(1).Min:=10.0;
Dat.Lista(1).Color_Max:=Rojo;
Dat.Lista(1).Color_Min:=Verde;
Dat.Lista(1).Etiqueta:="AAA";
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Diagrama estadístico de
barras (cont.)
125
UNIVERSIDAD
DE CANTABRIA
-- Usando literales
Dat.Lista(2):=(12.0, 8.0, Azul, Negro, "BBB");
Dat.Lista(3):=(22.0, 18.0, Rojo, Verde, "CCC");
Dat.Lista(4):=(32.0, 28.0, Azul, Negro, "DDD");
Dat.Lista(5):=(17.0, 8.0, Azul, Negro, "EEE");
Dat.Lista(6):=(19.0, 18.0, Rojo, Verde, "FFF");
Dat.Lista(7):=(8.0, 6.0, Azul, Negro, "GGG");
Dat.Lista(8):=(25.0, 16.0, Azul, Negro, "HHH");
Maximo:=32.0;
-- Hacer Dibujo
Grafico:=Canvas(640,480,"Estadistica");
Set_Font_Size(Grafico,12);
Ancho:=(600-Dat.Num_Datos*Esp_Entre_Col)/Dat.Num_Datos;
Pos:=20;
Factor:=400.0/Maximo;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
126
Ejemplo: Diagrama estadístico de
barras (cont.)
UNIVERSIDAD
DE CANTABRIA
for I in 1..Dat.Num_Datos loop
Alto:=Integer(Factor*Dat.Lista(I).Max);
Set_Fill(Grafico,Transforma(Dat.Lista(I).Color_Max));
Draw_Rectangle(Grafico,(Pos,440-Alto),Ancho,Alto);
Alto:=Integer(Factor*Dat.Lista(I).Min);
Set_Fill(Grafico,Transforma(Dat.Lista(I).Color_Min));
Draw_Rectangle(Grafico,(Pos,440-Alto),Ancho,Alto);
Draw_Text(Grafico,(Pos+2,460),Dat.Lista(I).Etiqueta);
Pos:=Pos+Ancho+Esp_Entre_Col;
end loop;
Wait(Grafico);
end Estadistica;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
127
UNIVERSIDAD
DE CANTABRIA
Creamos un enumerado llamado Colores para nuestros colores, con los valores Negro, Blanco, Rojo, ...
Usaremos un objeto de la clase Canvas_Type, de la librería Graphics_Windows para dibujar el gráfico de
barras.
Utilizamos el array Transforma para convertir nuestros colores a los utilizados en Graphics_Windows. Cada
casilla del array tiene como índice un enumerado del tipo Colores, y un valor del tipo Color_Type
El programa comienza rellenando la variable Datos_Estadistica con información para 8 datos a dibujar (a
modo de prueba)
• Primero se muestra cómo hacerlo rellenando cada campo individualmente, y luego mediante literales
También se crea la variable Maximo igual al máximo de todos los valores máximos; se usa para determinar
la escala del dibujo
La referencia en el lienzo para las coordenadas (X,Y) son la parte inferior izquierda: punto (0,0)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
128
UNIVERSIDAD
DE CANTABRIA
Para hacer el dibujo se hacen los siguientes pasos iniciales:
• Se crea el lienzo (del tipo Canvas_Type), que es una ventana para dibujar; hay que dar el tamaño en
píxeles y el título
• Se pone el tamaño de la fuente de texto para el lienzo a 12 puntos
• Se inicializan las variables siguientes:
- ancho (igual al ancho de cada barra, obtenido en función del número de barras que caben en el
dibujo)
- pos: indica la posición X de la parte izquierda de la siguiente barra a dibujar; se empieza en 20 para
dejar un poco de margen
- factor: es el factor de escala del dibujo en vertical, medido en píxeles/unidad de los valores
Luego se comienza un bucle para pintar cada barra
• Se calcula la altura de la barra en píxeles
• Se pone el color del relleno de las figuras al color del valor máximo
• Se dibuja el rectángulo de la barra del máximo
• Luego se hace lo mismo para la barra del mínimo y finalmente se pone la etiqueta de texto debajo de
las barras y se aumenta pos para dibujar la siguiente barra en el lugar apropiado
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
129
A observar
•
•
•
•
UNIVERSIDAD
DE CANTABRIA
Uso de un registro que contiene un array de registros
Uso de la clase Graphics_Windows
Uso de literales de registros
Uso de un array para transformar datos de un tipo enumerado a
otro
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.7. Subprogramas y paso de
parámetros
130
UNIVERSIDAD
DE CANTABRIA
Los subprogramas encapsulan
- un conjunto de instrucciones
- declaraciones de datos que esas instrucciones necesitan durante
su ejecución
Funcionamiento
- las instrucciones se ejecutan al invocar el subprograma desde otra
parte del programa
- se puede hacer intercambio de datos (a través de los parámetros)
- al finalizar el subprograma, la ejecución continúa por la instrucción
siguiente a la invocación
- las declaraciones de un subprograma se destruyen a su
finalización
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Subprogramas (cont.)
131
UNIVERSIDAD
DE CANTABRIA
Ventajas
• evitan la duplicidad de código
• son el primer pilar de la división del programa en partes
Pero no sirven para hacer módulos de programa independientes
Un módulo de programa independiente tiene
• datos cuya vida es de un ámbito mayor que el del subprograma
• operaciones para manejar esos datos, en forma de
subprogramas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
132
Subprogramas (cont.)
UNIVERSIDAD
DE CANTABRIA
En Ada hay dos tipos de subprogramas:
• funciones: retornan un dato utilizable en una expresión
• procedimientos: se invocan como una instrucción aparte
- pueden retornar varios datos, mediante parámetros
Son equivalentes a las funciones de C y similares a los métodos
de Java/C++
• aunque no se asocian necesariamente con un objeto como pasa
en Java o C++
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1.7.1. Procedimientos
133
UNIVERSIDAD
DE CANTABRIA
Componentes de un procedimiento:
• nombre
• parámetros formales: datos que intercambia con la parte del
programa que lo invoca
- de entrada (in): tipo por omisión
- de salida (out)
- de entrada y salida (in out)
• declaraciones
• instrucciones
Se pueden compilar aparte (capítulo siguiente) o poner en la parte
declarativa de otro módulo
• por ejemplo dentro de otros subprogramas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
134
UNIVERSIDAD
DE CANTABRIA
Los parámetros o argumentos de los subprogramas Ada pueden ser de entrada, salida, o entrada/salida
En Ada no se indica si el parámetro se pasa por valor (se pasa una copia) o por referencia (se pasa la
dirección de memoria en la que se encuentra); esto lo elige el compilador para conseguir la máxima
eficiencia
• si el dato es corto lo pasa por valor
• si es grande lo hace por referencia
Por tanto, en Ada el programador expresa la intención de uso del dato, y el compilador elige la mejor
implementación posible
En C/Java la situación es diferente. Los parámetros se pasan sólo por valor.
• En C, si se desea pasar un parámetro por referencia se crea una referencia explícita, con un puntero
que se pasa por valor; ello es necesario si se desea que la función modifique el parámetro original
• En Java las variables de los tipos elementales sólo se pueden pasar por valor, pues no hay punteros
explícitos; en cambio, los objetos se pasan siempre por referencia (el valor de su dirección)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
135
Estructura de la declaración de un
procedimiento
UNIVERSIDAD
DE CANTABRIA
procedure Nombre
(arg1 : in tipo1;
arg2 : out tipo2;
arg3 : in out tipo3;
arg4,arg5 : in tipo4)
is
declaraciones;
begin
instrucciones;
end Nombre;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo
136
UNIVERSIDAD
DE CANTABRIA
Calcular la suma de dos números y mostrarla en la pantalla
procedure Suma (X,Y : in Float; Suma : out Float) is
begin
Suma:=X+Y;
Ada.Text_IO.Put_Line("Suma: "&Float’Image(Suma));
end Suma;
Los parámetros formales:
• existen sólo dentro del procedimiento
• si son in, se tratan como constantes
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Uso de un procedimiento
137
UNIVERSIDAD
DE CANTABRIA
Llamada a un procedimiento
• Se escribe como una instrucción:
Nombre(parámetros_actuales);
• Cada parámetro actual se asigna a un parámetro formal
- por orden:
Suma(3.0,A,B);
- por nombre:
Suma(X =>3.0, Y=>A, Suma =>B);
• Deben respetar las reglas de compatibilidad de tipos
• Los in son expresiones
• Los out e in out deben ser variables
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
138
Uso de un procedimiento (cont.)
UNIVERSIDAD
DE CANTABRIA
Es posible dar valor por omisión a un parámetro formal. En ese
caso, se puede omitir en la llamada.
procedure Desplazamiento_Muelle
(F : Fuerza; K : Constante_Muelle; T : Temperatura:=25.0)
is ...
Desplazamiento_Muelle(F,K,T);
Desplazamiento_Muelle(F,K);
-- T vale 25.0
Ejemplo: mostraremos cómo hacer el producto escalar de dos
vectores con procedimientos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de manejo de arrays con
procedimientos
139
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Ada.Integer_Text_IO,Ada.Float_Text_IO;
use Ada.Text_IO;
use Ada.Integer_Text_IO;
use Ada.Float_Text_IO;
procedure Producto_Con_Proc is
Dimension_Max : constant Integer:= 100;
subtype Indice is Integer range 1..Dimension_Max;
type Vector is array (Indice) of Float;
V1,V2
: Vector;
Dimension
: Indice;
Prod_Escalar : Float;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de manejo de arrays con
procedimientos (cont.)
140
UNIVERSIDAD
DE CANTABRIA
procedure Lee_Vector (
N : in Indice;
V : out Vector) is
begin
for I in 1..N loop
Put("Introduce componente ");
Put(I);
Put(": ");
Get(V(I));
Skip_Line;
end loop;
end Lee_Vector;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
141
Ejemplo de manejo de arrays con
procedimientos (cont.)
UNIVERSIDAD
DE CANTABRIA
procedure Calcula_Prod_Escalar (
N
: in Indice;
V1
: in Vector;
V2
: in Vector;
Prod : out Float) is
begin
Prod:=0.0;
for I in 1..N loop
Prod:=Prod+ V1(I)*V2(I);
end loop;
end Calcula_Prod_Escalar;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de manejo de arrays con
procedimientos (cont.)
142
UNIVERSIDAD
DE CANTABRIA
begin
Put("Introduce dimension : ");
Get(Dimension);
Skip_Line;
Lee_Vector(Dimension,V1);
Lee_Vector(Dimension,V2);
Calcula_Prod_Escalar(Dimension,V1,V2,Prod_Escalar);
Put("El producto escalar es : ");
Put(Prod_Escalar);
New_Line;
end Producto_Con_Proc;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
143
UNIVERSIDAD
DE CANTABRIA
Podemos ver que hemos creado dos procedimientos, dentro de las declaraciones del procedimiento que
representa el programa principal
• Lee_Vector sirve para leer los componentes de un vector desde teclado; se le pasa como parámetro
de entrada la dimensión del vector y como parámetro de salida la variable donde se deposita el vector
leído
• Calcula_Producto_Escalar tiene como parámetros de entrada la dimensión de los vectores y los
dos vectores a multiplicar, y da como parámetro de salida el resultado, que es un número real
El programa principal se encarga de:
• Leer la dimensión del vector
• Invocar a Lee_Vector dos veces para leer cada uno de los dos vectores
• Llamar a Calcula_Producto_Escalar
• Mostrar en pantalla el resultado
Puede observarse la ventaja del procedimiento Lee_Vector, que permite usar dos veces las mismas
instrucciones sin necesidad de repetirlas.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
144
1.7.2. Funciones
UNIVERSIDAD
DE CANTABRIA
Son iguales a los procedimientos, pero retornan un valor que se
puede utilizar en una expresión
Sólo admiten parámetros de entrada. Declaración:
function Nombre (parámetros_formales) return Tipo is
declaraciones;
begin
instrucciones;
end Nombre;
Al menos una de las instrucciones debe ser
return valor;
Esta instrucción finaliza la función. Es un error acabar la función
sin ejecutar esta instrucción
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo:
145
UNIVERSIDAD
DE CANTABRIA
Cálculo del cuadrado de un número real
function Cuadrado (X : Float) return Float is
begin
return X*X;
end Cuadrado;
Para invocar la función se hace en una expresión:
Y:=Cuadrado(Z)*2.0;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de una función operador
146
UNIVERSIDAD
DE CANTABRIA
Se pueden definir operadores en Ada mediante funciones cuyo
nombre es "operador"
type Vector is array (Integer range <>) of Float;
-- Suma de vectores
function "+" (A,B : in Vector) return Vector is
Resultado : Vector(A'range);
begin
for I in A'range loop
Resultado(I):=A(I)+B(I);
end loop;
return Resultado;
end "+";
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
147
Ejemplo de uso de esta función
UNIVERSIDAD
DE CANTABRIA
declare
N
: Integer := 33;
V1,V2,V3 : Vector(1..N);
begin
...
V3:=V1+V2;
...
end;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Librería de Servicios Numéricos
148
UNIVERSIDAD
DE CANTABRIA
package Ada.Numerics is
pragma Pure (Numerics);
Argument_Error : exception;
Pi : constant :=
3.14159_26535_89793_23846_26433_
83279_50288_41971_69399_37511;
e : constant :=
2.71828_18284_59045_23536_02874_
71352_66249_77572_47093_69996;
end Ada.Numerics;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
149
UNIVERSIDAD
DE CANTABRIA
La librería Ada.Numerics define las constantes elementales e y pi
En el código de arriba se ha puesto la parte fraccionaria en dos líneas, para que quepa, pero en realidad
debe ir en una sola
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
150
Librería estándar de funciones
matemáticas
UNIVERSIDAD
DE CANTABRIA
package Ada.Numerics.Elementary_Functions is
function
function
function
function
function
Sqrt
Log
Log
Exp
"**"
(X
(X
(X, Base
(X
(Left, Right
:
:
:
:
:
Float)
Float)
Float)
Float)
Float)
return
return
return
return
return
Float;
Float;
Float;
Float;
Float;
function
function
function
function
function
function
function
function
Sin
Sin
Cos
Cos
Tan
Tan
Cot
Cot
(X
(X,
(X
(X,
(X
(X,
(X
(X,
:
:
:
:
:
:
:
:
Float)
Float)
Float)
Float)
Float)
Float)
Float)
Float)
return
return
return
return
return
return
return
return
Float;
Float;
Float;
Float;
Float;
Float;
Float;
Float;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
Cycle
Cycle
Cycle
Cycle
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
151
Librería estándar de funciones
matemáticas (cont.)
function
function
function
function
Arcsin
Arcsin
Arccos
Arccos
(X
(X, Cycle
(X
(X, Cycle
:
:
:
:
Float)
Float)
Float)
Float)
return
return
return
return
UNIVERSIDAD
DE CANTABRIA
Float;
Float;
Float;
Float;
function Arctan
(Y : Float; X : Float := 1.0) return Float;
function Arctan
(Y : Float; X : Float := 1.0; Cycle : Float) return
Float;
function Arccot
(X : Float; Y : Float := 1.0) return Float;
function Arccot
(X : Float; Y : Float := 1.0; Cycle : Float) return
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Librería estándar de funciones
matemáticas (cont.)
function
function
function
function
function
function
function
function
Sinh
Cosh
Tanh
Coth
Arcsinh
Arccosh
Arctanh
Arccoth
(X
(X
(X
(X
(X
(X
(X
(X
:
:
:
:
:
:
:
:
Float)
Float)
Float)
Float)
Float)
Float)
Float)
Float)
return
return
return
return
return
return
return
return
Float;
152
UNIVERSIDAD
DE CANTABRIA
Float;
Float;
Float;
Float;
Float;
Float;
Float;
Float;
end Ada.Numerics.Elementary_Functions;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
153
Notas:
UNIVERSIDAD
DE CANTABRIA
La librería Ada.Numerics.Elementary_Functions define las funciones aritméticas elementales:
• Sqrt(x): raíz cuadrada
• Log(x): logaritmo neperiano
• Log(x,base): logaritmo en la base especificada
• "**": elevar un número real a otro
• Sin(x), Cos(x), Tan(x), Cot(x): funciones trigonométricas con radianes: seno, coseno,
tangente, cotangente
• Sin(x,cycle), Cos(x,cycle), Tan(x,cycle), Cot(x,cycle): funciones trigonométricas
con ángulos en otras unidades. Cycle es el número de unidades en la circunferencia; por ejemplo,
para grados sexagesimales utilizar cycle => 360.0
• Arcsin(x), Arccos(x): funciones trigonométricas inversas en radianes: arcoseno y arcocoseno
• Arcsin(x,cycle), Arccos(x,cycle): funciones trigonométricas inversas con ángulos en otras
unidades
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
154
UNIVERSIDAD
DE CANTABRIA
• Arctan(y,x), Arccot(y,x): funciones trigonométricas inversas en radianes: arcotangente(y/x)
y arcocotangente(y/x); se usan los signos de y y x para obtener el ángulo correcto en los cuatro
cuadrantes; por ejemplo, para arctan, si y es el seno del ángulo y x el coseno se obtiene el ángulo
correctamente; es equivalente al atan2() de C o Java
• Arctan(y,x,cycle), Arccot(y,x,cycle): Igual que las operaciones anteriores, pero con el
ángulo en otras unidades
• Sinh(x), Cosh(x), Tanh(x), Coth(x): funciones trigonométricas hiperbólicas: seno, coseno,
tangente y cotangente hiperbólicas
• Arcsinh(x), Arccosh(x), Arctanh(x), Arccoth(x): funciones trigonométricas hiperbólicas
inversas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplos de uso de las funciones
matemáticas
155
UNIVERSIDAD
DE CANTABRIA
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;
procedure Prueba is
A,B,C : Float;
begin
A:=Sqrt(2.13);
B:=Log(A);
C:=Sin(B);
A:=Sin(B,360.0);
B:=A**C;
end Prueba;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
-----
logaritmo neperiano
B en radianes
B en grados
elevar A a C
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
156
1.8 Reglas de visibilidad
UNIVERSIDAD
DE CANTABRIA
Dan respuesta a la pregunta: ¿Desde qué parte del programa es
visible (se puede utilizar) una declaración?
Se definen en función de bloques: elementos de programa con la
siguiente estructura:
encabezamiento
declaraciones;
begin
instrucciones;
end;
Por ejemplo: procedimientos, funciones, instrucción declare
(también paquetes y tareas, que veremos más adelante)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Reglas de visibilidad resumidas
157
UNIVERSIDAD
DE CANTABRIA
Las declaraciones:
• Regla 1: Son visibles desde donde aparecen hasta el final del
bloque
• Regla 2: Son visibles dentro del bloque donde aparecen y en los
bloques contenidos en él (siempre que se cumpla la regla 1)
• Regla 3: Un nombre interno enmascara uno externo
- excepto en los subprogramas "sobrecargados" (del mismo
nombre, pero diferentes parámetros formales)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo
Objeto
1-22
A
2-22
B (de P1) 2-11, 16-22
P2
3-22
F,G
8-22
P3
9-22
H,I
10-18
P4
11-18
J,K,B
12-15
L,M
19-22
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
UNIVERSIDAD
DE CANTABRIA
Visibilidad (líneas)
P1
158
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
procedure P1 is
A,B : Integer;
procedure P2 is
D,E : Integer
begin
...
end P2;
F,G : Integer;
procedure P3 is
H,I : Integer;
procedure P4 is
J,K,B : Integer;
begin
...
end P4;
begin
...
end P3;
L,M : Integer;
begin
...
end P1;
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
159
Intercambio de información entre
subprogramas
UNIVERSIDAD
DE CANTABRIA
Podemos intercambiar información de dos maneras:
• Variables globales: visibles por varios subprogramas
- frente a variables locales, declaradas y visibles sólo localmente por
un subprograma
• Parámetros
El método recomendable es el de parámetros
• el uso de variables globales crea dependencias entre partes del
programa
• hace más difícil entender lo que hace un procedimiento
Recomendación: salvo que haya muy pocas (una) y esté muy
justificado, no usar variables globales.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
160
Parte I: Fundamentos de programación
en lenguaje Ada
UNIVERSIDAD
DE CANTABRIA
1. Elementos básicos del lenguaje
2. Estructuras de datos dinámicas
3. Modularidad y programación orientada a objetos
4. Tratamiento de errores
5. Abstracción de tipos mediante unidades genéricas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1
2.1. Relaciones entre datos
UNIVERSIDAD
DE CANTABRIA
En muchas estructuras de datos es preciso establecer relaciones
o referencias entre diferentes datos.
• ahorran espacio al no repetir datos
• evitan inconsistencias
Si los datos están en un array, se pueden utilizar cursores
• el cursor es un entero que indica el número de la casilla del array
donde está el dato
Si los datos no están en un array deben utilizarse punteros (si los
soporta el lenguaje de programación)
• son datos especiales que sirven para apuntar o referirse a otros
datos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
2
Ejemplo: listas de alumnos de
asignaturas
Asignatura 1
FACULTAD DE CIENCIAS
Asignatura 2
María Fdez.
Gral. Dávila, 23...
María Fdez.
Gral. Dávila, 23...
Jesús Pérez
Canalejas, 13...
Andrés Puente
c/Salamanca, 8...
Andrés Puente
c/Salamanca, 8...
Pepe Gómez
c/Cádiz, 3...
GRUPO DE COMPUTADORES Y TIEMPO REAL
UNIVERSIDAD
DE CANTABRIA
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
¡Hay datos
repetidos!
3
Alternativa: referencias entre datos
Alumnos
Asignatura 1
UNIVERSIDAD
DE CANTABRIA
Asignatura 2
Pepe Gómez
c/Cádiz, 3...
María Fdez.
Gral. Dávila, 23...
Andrés Puente
c/Salamanca, 8...
Jesús Pérez
Canalejas, 13...
...
...
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
...
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
2.2. Punteros
4
UNIVERSIDAD
DE CANTABRIA
Los punteros o tipos acceso proporcionan acceso a otros objetos
de datos
Hasta ahora el acceso era sólo por el nombre o un cursor
• ahora el puntero es más flexible
Los objetos apuntados por un puntero se pueden crear o destruir
de forma independiente de la estructura de bloques
Declaración:
type nombre is access tipo;
Ejemplo:
type P_Integer is access Integer;
P1, P2 : P_Integer;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Punteros (cont.)
5
UNIVERSIDAD
DE CANTABRIA
Hay un valor predefinido, null, que es el valor por omisión, y no
se refiere a ningún dato
Creación dinámica de objetos:
P1:= new Integer;
P2:= new Integer’(37);
Uso del puntero: por el nombre
P1:=P2; -- copia sólo la referencia
Uso del valor al que apunta el puntero:
• completo: nombre_puntero.all
• campo de un registro: nombre_puntero.campo
• casilla de un array: nombre_puntero(índice)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
6
Ejemplo
UNIVERSIDAD
DE CANTABRIA
type Coord is record
X,Y : Float;
end record;
type Vector is array(1..3) of Float;
type P_Coord is access Coord;
type P_Vector is access Vector;
PV1, PV2 : P_Vector;
PC1, PC2 : P_Coord;
...
PV1:=new Vector;
PV2:=new Vector’(1.0,2.0,3.0);
PV1.all:=PV2.all;
-- copia el valor completo
PV1(3):=3.0*PV2(2); -- usa casillas individuales del array
PC1:=new Coord’(2.0,3.0);
PC1.Y:=9.0;
-- usa un campo individual del registro
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
7
2.3. Estructuras de datos dinámicas
UNIVERSIDAD
DE CANTABRIA
Son útiles cuando se usan para crear estructuras de datos con
relaciones entre objetos.
Por ejemplo, una lista enlazada
Contenido
Próximo
A1
A2
...
An
Celda
• cada elemento tiene un contenido y un puntero al próximo
• el último tiene un puntero “próximo” nulo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
8
Flexibilidad de la estructura de datos
dinámica
UNIVERSIDAD
DE CANTABRIA
Se pueden insertar nuevos elementos en la posición deseada,
eficientemente:
A1
A2
...
An
X
Diferencias con el array:
• los arrays tienen tamaño fijo: ocupan lo mismo, incluso medio
vacíos
• con estructuras de datos dinámicas se gasta sólo lo preciso
• pero se necesita espacio para guardar los punteros
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
9
Definición de estructuras de datos
dinámicas en Ada
UNIVERSIDAD
DE CANTABRIA
Hay una dependencia circular entre el tipo puntero y el tipo celda
• se resuelve con una declaración incompleta de tipo
Ejemplo
type Celda; -- declaración incompleta de tipo
type P_Celda is access Celda;
type Celda is record
Contenido : ...; -- poner el tipo deseado
Proximo : P_Celda;
end record;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de creación de una lista
enlazada
10
UNIVERSIDAD
DE CANTABRIA
Lista : P_Celda;
Lista:=new Celda’(1,null); -- suponemos el contenido entero
Lista.proximo:=new Celda’(2,null);
Lista.proximo.proximo:=new Celda’(3,null);
Para evitar extender la notación punto indefinidamente, podemos
utilizar un puntero auxiliar:
P : P_Celda;
P:=Lista.proximo.proximo;
P.proximo:=new Celda’(4,null);
P:=P.proximo; -- para seguir utilizando P con la siguiente celda
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Estructuras de datos dinámicas (cont.)
11
UNIVERSIDAD
DE CANTABRIA
Veremos abundantes ejemplos en el capítulo de los tipos
abstractos de datos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
12
2.4 Punteros a objetos estáticos
UNIVERSIDAD
DE CANTABRIA
Hasta ahora, todos los punteros lo eran a objetos creados
dinámicamente (con new)
Es posible crear punteros a objetos (variables, constantes o
subprogramas) estáticos. Ejemplos:
type Acceso_Entero is access all Integer;
type Acceso_Cte is access constant Integer;
Para poder crear un puntero a una variable estática, ésta se debe
haber creado con la mención “aliased”:
Num : aliased Integer:=5;
Para crear el puntero se utiliza el atributo ’Access:
P : Acceso_Entero := Num’Access;
La principal utilidad es para llamar a funciones C
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Punteros a objetos estáticos (cont.)
13
UNIVERSIDAD
DE CANTABRIA
Este atributo sólo se puede usar si el tipo puntero está declarado
en el mismo nivel de accesibilidad que el objeto, o en uno más
profundo
• motivo: impedir tener un puntero a un objeto que ya no existe
• lo mejor es tener el objeto y el tipo puntero declarados en el
mismo sitio
En caso de que sea imprescindible romper esta norma, se puede
usar el atributo ’Unchecked_Access, que también proporciona el
puntero pero sin restricciones
• el uso de este atributo es peligroso
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
14
Parte I: Fundamentos de programación
en lenguaje Ada
UNIVERSIDAD
DE CANTABRIA
1. Elementos básicos del lenguaje
2. Estructuras de datos dinámicas
3. Modularidad y programación orientada a objetos
4. Tratamiento de errores
5. Abstracción de tipos mediante unidades genéricas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
1
3.1. Diseño modular y orientado a
objetos
UNIVERSIDAD
DE CANTABRIA
El diseño modular es una técnica que viene usándose desde hace
mucho tiempo
El problema es cómo partir en módulos independientes
• antes solía hacerse de acuerdo a criterios funcionales (agrupar
funciones similares)
Librería de
Gráficos
Estructuras de
Datos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
Operaciones de
Dibujar
Operaciones de
Modificación
...
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Partición con criterios funcionales
2
UNIVERSIDAD
DE CANTABRIA
Inconvenientes
• Cada figura (objeto del espacio problema) reside en varios
módulos de programa
- por tanto estos módulos no son independientes
• Un cambio en el objeto del espacio problema implica cambiar
muchos módulos, y volverlos a probar
• Añadir nueva funcionalidad implica normalmente tocar varios
módulos, y volverlos a probar
- por ejemplo, añadir una figura nueva.
• En definitiva, el software es difícil de cambiar o extender y poco
reutilizable
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3
Diseño orientado a objetos
UNIVERSIDAD
DE CANTABRIA
Se puede utilizar otra aproximación a la partición en módulos:
• división orientada a objetos
• cada objeto del problema real que es preciso resolver es un
módulo del programa
• se encapsulan juntas la definición del objeto y todas sus
operaciones
El diseño de programas orientado a objetos pretende:
• simplificar la modificación y extensión del software, haciendo
que la mayor parte del mismo sea reutilizable
• además es más fácil de entender ya que existe relación directa
entre la estructura del software y la del problema
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4
Ejemplo de diseño orientado a objetos
UNIVERSIDAD
DE CANTABRIA
Librería de
Gráficos
Línea recta y
sus operaciones
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
Rectángulo y sus
operaciones
Círculo y sus
operaciones
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ventajas
...
5
UNIVERSIDAD
DE CANTABRIA
Si el diseño es orientado al objeto:
• el cambio interno en un objeto afecta a un solo módulo
• en muchos casos, extender la funcionalidad no implica
modificar el software existente, sino sólo añadir nuevos objetos
• el software es más reutilizable
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
6
3.2. Concepto de clase y objeto
UNIVERSIDAD
DE CANTABRIA
Un objeto es un elemento de programa que se caracteriza por:
• atributos o campos: son datos contenidos en el objeto, y que
determinan su estado
• operaciones o métodos: son operaciones con las que podemos
solicitar información del objeto, o modificarla
- Están compuestas por secuencias de instrucciones que operan
con los atributos, y que pueden invocar operaciones de otros
objetos
Una clase representa una definición de un módulo de programa, a
partir de la cual se pueden crear muchos objetos
• Cada uno de estos objetos es una instancia de la clase
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
7
Concepto de clase y objeto (cont.)
Se intenta siempre corresponder los
objetos de un programa con objetos
del problema que éste resuelve.
Ejemplo: mostrar uno o varios
gráficos de funciones de una variable.
Los gráficos representan una clase
de objetos.
Cada gráfica individual representa un
objeto de la clase “Gráfico”.
Gráfico
Título
Puntos (X,Y) del gráfico
Número de puntos
Títulos de los ejes
Crear un gráfico nuevo
Añadir un punto
Pintar el gráfico
Poner el título
atributos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
UNIVERSIDAD
DE CANTABRIA
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo
operaciones
8
UNIVERSIDAD
DE CANTABRIA
with Plot_Windows; use Plot_Windows;
procedure Experimento is
Plot : Plot_Window_Type:=
Plot_Window("Experimento","Tiempo (s)","Temperatura (C)");
begin
Set_Graph_Title(Plot,"Exp. 7");
-- Anadir los puntos
Add_Point(Plot,0.0,20.4);
Add_Point(Plot,1.0,23.2);
Add_Point(Plot,2.0,24.8);
Add_Point(Plot,3.0,25.7);
Add_Point(Plot,4.0,26.1);
Add_Point(Plot,5.0,26.5);
-- Pintar el gráfico
Wait(Plot);
end Experimento;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
9
3.3. Paquetes Ada
UNIVERSIDAD
DE CANTABRIA
Motivación:
• Encapsular juntas declaraciones de constantes, tipos y
subprogramas
• Programación orientada a objetos: encapsulamiento de clases
con especificación de una interfaz visible, y ocultando los
detalles internos
Los paquetes Ada tienen dos partes:
• parte visible o especificación
- a su vez, tiene una parte no visible o privada
• cuerpo, con los detalles internos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Declaración de paquetes
10
UNIVERSIDAD
DE CANTABRIA
Se ponen en la parte de declaraciones de un programa (o en un
fichero aparte como veremos más adelante)
Especificación
package Nombre is
declaraciones de datos y tipos;
declaraciones de tipos y constantes privadas;
declaraciones de cabeceras de subprogramas;
declaraciones de especificaciones de paquetes;
private
otras declaraciones necesarias más abajo;
declaraciones completas de los tipos y constantes privados
end Nombre;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Declaración de paquetes (cont.)
11
UNIVERSIDAD
DE CANTABRIA
Cuerpo
package body Nombre is
declaraciones de datos y subprogramas;
declaraciones de subprogramas y paquetes de la
especificación;
begin
instrucciones de inicialización;
end Nombre;
Las instrucciones de inicialización
• se ejecutan una sóla vez antes de que se use el paquete
• son opcionales (junto a su begin)
• sirven para inicializar variables declaradas en el paquete
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
12
Uso de un paquete
UNIVERSIDAD
DE CANTABRIA
Uso de objetos de la parte visible de un paquete:
Paquete.objeto
Con cláusula use se puede usar el objeto directamente
use Paquete;
Con una cláusula use type se pueden usar los operadores de un
tipo directamente
use type Paquete.Tipo;
• Si no se hace, los operadores se tendrían que usar como
funciones:
c:=Paquete."+"(a,b); -- en lugar de c:=a+b;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Números complejos
13
UNIVERSIDAD
DE CANTABRIA
package Complejos is
type Complejo is private;
function Haz_Complejo (Re,Im : Float) return Complejo;
function Real(C : Complejo) return Float;
function Imag(C : Complejo) return Float;
function "+" (C1,C2 : Complejo) return Complejo;
function Image(C : Complejo) return String;
private
type Complejo is record
Re,Im : Float;
end record;
end Complejos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo (cont.)
14
UNIVERSIDAD
DE CANTABRIA
package body Complejos is
function "+" (C1,C2 : Complejo) return Complejo is
begin
return (C1.Re+C2.Re,C1.Im+C2.Im);
end "+";
function Haz_Complejo (Re,Im : Float) return Complejo is
begin
return (Re,Im);
end Haz_Complejo;
function Imag (C : Complejo) return Float is
begin
return C.Im;
end Imag;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
15
Ejemplo (cont.)
UNIVERSIDAD
DE CANTABRIA
function Image (C : Complejo) return String is
begin
if C.Im>=0.0 then
return Float’Image(C.Re)&" + "&Float’Image(C.Im)&" J";
else
return Float’Image(C.Re)&" - "&Float’Image(abs C.Im)&" J";
end if;
end Image;
function Real (C : Complejo) return Float is
begin
return C.Re;
end Real;
end Complejos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de uso
16
UNIVERSIDAD
DE CANTABRIA
with Complejos, Ada.Text_IO;
use Ada.Text_IO;
use type Complejos.Complejo;
procedure Prueba_Complejos is
C1,C2,C3 : Complejos.Complejo;
begin
C1:=Complejos.Haz_Complejo(3.0,4.0);
C2:=Complejos.Haz_Complejo(5.0,-6.0);
Put_Line("C1="&Complejos.Image(C1));
Put_Line("C2="&Complejos.Image(C2));
C3:=C1+C2;
Put_Line("Parte real C3="&Float’Image(Complejos.Real(C3)));
Put_Line("Parte imag C3="&Float’Image(Complejos.Imag(C3)));
end Prueba_Complejos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.4. Compilación separada
17
UNIVERSIDAD
DE CANTABRIA
En Ada se pueden compilar separadamente:
• subprogramas
• especificaciones de paquetes
• cuerpos de paquetes
Cada uno de ellos se llama “unidad de librería”
Para usar una unidad compilada separadamente se debe usar una
cláusula with.
El orden de compilación, en algunos compiladores, es importante.
En Gnat no importa
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
18
Ejemplo:
UNIVERSIDAD
DE CANTABRIA
p.adb
pral.adb
with P,Pack
procedure Pral
is
...
begin
Pack.P(I)
P;
Pack.Q;
...
end Pral;
with Pack
procedure P is
...
begin
Pack.Q;
...
end P;
pack.adb
pack.ads
package Pack is
procedure P
(I : Integer);
procedure Q;
end Pack;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
package body Pack is
procedure P
(I : Integer)
is ...
procedure Q
is ...
end Pack;
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Cláusulas use
19
UNIVERSIDAD
DE CANTABRIA
Observar que no tiene nada que ver la compilación separada
(with) con la cláusula use
Las cláusulas use se usan para no tener que poner el nombre del
paquete delante del objeto
Criterios para las cláusulas use
• Poner use para paquetes muy conocidos y
usados(Ada.Text_IO)
• No poner cláusula use para paquetes nuestros
• Poner cláusula use type para poder usar los operadores de un
tipo directamente
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.5. Reglas de visibilidad
20
UNIVERSIDAD
DE CANTABRIA
Quedan modificadas en los siguientes aspectos:
• Las declaraciones de la especificación (visibles y privadas) son
visibles en el cuerpo
• Las declaraciones de la parte visible de la especificación son
visibles en el bloque en que se declara el paquete:
- si se antepone el nombre del paquete
- o mediante cláusula use
• Las declaraciones del cuerpo sólo son visibles en ese cuerpo.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
21
Paquetes hijos
UNIVERSIDAD
DE CANTABRIA
Es posible crear paquetes que son “hijos” de otros, formando una
estructura jerárquica.
Lo que caracteriza a un paquete hijo es que tiene visibilidad sobre
la parte privada del padre, pero no sobre el cuerpo
Para declararlo se usa la notación “.” en el nombre
package Padre is
...
end Padre;
package Padre.Detalle is
...-- puede usar la parte privada de Padre
end Padre.Detalle;
En Gnat el fichero debe tener el nombre padre-detalle.ads
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
22
3.6. Tipos de paquetes
UNIVERSIDAD
DE CANTABRIA
1. Paquetes sin cuerpo
2. Librerías:
- engloban operaciones relacionadas entre sí
3. Paquetes con objetos o máquinas de estados abstractas
- encapsulan un objeto (un dato oculto en el cuerpo) y operaciones
para manipularlo
4. Paquetes con clases o tipos de datos abstractos
- encapsulan un tipo de datos y operaciones para manipular objetos
de ese tipo
- el tipo de datos es privado
- el usuario puede crear todos los objetos de ese tipo de datos que
desee
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete sin cuerpo
23
UNIVERSIDAD
DE CANTABRIA
package Constantes_Atomicas is
Carga_Electron
Coulombios
Masa_Electron
Masa_Neutron
Masa_Proton
: constant := 1.602E-19;
--
: constant := 0.9108E-30;
: constant := 1674.7E-30;
: constant := 1672.4E-30;
-- Kg
-- Kg
-- Kg
-- Este package no tiene "body"
end Constantes_Atomicas;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
24
Paquete con un objeto o máquina de
estados (1/3)
UNIVERSIDAD
DE CANTABRIA
with Elementos; -- define el tipo Elemento, que es discreto
use Elementos;
package Un_Conjunto is
procedure Inserta (E : Elemento);
procedure Extrae
(E : Elemento);
function Pertenece (E: Elemento) return Boolean;
end Un_Conjunto;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete con un objeto o máquina de
estados (2/3)
25
UNIVERSIDAD
DE CANTABRIA
package body Un_Conjunto is
type Conjunto is array (Elemento) of Boolean;
C : Conjunto; -- aquí está la variable que contiene el estado
procedure Inserta (E : Elemento) is
begin
C(E):=True;
end Inserta;
procedure Extrae (E : Elemento) is
begin
C(E):=False;
end Extrae;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete con un objeto o máquina de
estados (3/3)
26
UNIVERSIDAD
DE CANTABRIA
function Pertenece (E: Elemento) return Boolean is
begin
return C(E);
end Pertenece;
begin -- Inicialización del estado del paquete
C:= Conjunto'(Conjunto'range=>False);
end Un_Conjunto;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
27
Paquete con una clase o tipo abstracto
de datos (1/3)
UNIVERSIDAD
DE CANTABRIA
with Elementos; -- define el tipo Elemento, que es discreto
use Elementos;
package Conjuntos_Privados is
type Conjunto is private;
function Vacio return Conjunto;
procedure Inserta (E : Elemento;
C : in out Conjunto);
procedure Extrae (E : Elemento;
C : in out Conjunto);
-- pertenencia
function "<" (E: Elemento; C: Conjunto) return Boolean;
private
type Conjunto is array (Elemento) of Boolean;
end Conjuntos_Privados;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete con una clase o tipo abstracto
de datos (2/3)
28
UNIVERSIDAD
DE CANTABRIA
package body Conjuntos_Privados is
function Vacio return Conjunto is
begin
return Conjunto'(Conjunto'range=>False);
end Vacio;
procedure Inserta (E : Elemento;
C : in out Conjunto) is
begin
C(E):=True;
end Inserta;
procedure Extrae (E : Elemento;
C : in out Conjunto) is
begin
C(E):=False;
end Extrae;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete con una clase o tipo abstracto
de datos (3/3)
29
UNIVERSIDAD
DE CANTABRIA
-- pertenencia
function "<" (E: Elemento; C: Conjunto) return Boolean is
begin
return C(E);
end "<";
end Conjuntos_Privados;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
30
Algunos paquetes de librerías:
Números aleatorios
UNIVERSIDAD
DE CANTABRIA
package Ada.Numerics.Float_Random is
-- Basic facilities
type Generator is limited private;
subtype Uniformly_Distributed is
Float range 0.0 .. 1.0;
function Random (Gen : Generator)
return Uniformly_Distributed;
procedure Reset
procedure Reset
(Gen
: Generator);
(Gen
: Generator;
Initiator : Integer);
-- Advanced facilities
...
end Ada.Numerics.Float_Random;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de uso de números aleatorios:
31
UNIVERSIDAD
DE CANTABRIA
with Ada.Numerics.Float_Random, Text_Io, Ada.Integer_Text_Io;
use Ada.Numerics.Float_Random, Text_Io, Ada.Integer_Text_Io;
procedure Dado is
Gen : Generator;
Pulsada : Boolean;
C : Character;
begin
Put_Line("Pulsa una tecla para parar");
Reset(Gen);
loop
Put(Integer(6.0*Random(Gen)+0.5));
New_Line;
delay 0.5;
Get_Immediate(C,Pulsada);
exit when Pulsada;
end loop;
end Dado;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Librería de strings variables (1/3)
32
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO; use Ada;
package Var_Strings is
Max_Length : constant Integer := 80;
type Var_String is private;
Null_Var_String : constant Var_String;
function To_String
(V : Var_String) return String;
function To_Var_String (S : String)
return Var_String;
function Length (V : Var_String) return Natural;
procedure Get_Line (V : out Var_String);
procedure Put_Line (V : in Var_String);
procedure Put
(V : in Var_String);
procedure Get_Line (F : in out Text_IO.File_Type;
V : out Var_String);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
33
Librería de strings variables (2/3)
procedure Put_Line (F
V
procedure Put
(F
V
function
function
function
function
function
function
function
function
function
:
:
:
:
in
in
in
in
UNIVERSIDAD
DE CANTABRIA
out Text_IO.File_Type;
Var_String);
out Text_IO.File_Type;
Var_String);
"&" (V1,V2 : Var_String) return Var_String;
"&" (V : Var_String; S : String) return Var_String;
"&" (S : String; V : Var_String) return Var_String;
"&" (V : Var_String; C : Character) return Var_String;
"=" (V1,V2 : Var_String) return Boolean;
">" (V1,V2 : Var_String) return Boolean;
"<" (V1,V2 : Var_String) return Boolean;
">=" (V1,V2 : Var_String) return Boolean;
"<=" (V1,V2 : Var_String) return Boolean;
function Element (V : Var_String; Index : Positive)
return Character;
function Slice (V : Var_String; Index1 : Positive;
Index2 : Natural) return Var_String;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Librería de strings variables (3/3)
34
UNIVERSIDAD
DE CANTABRIA
function To_Upper (V : Var_String) return Var_String;
function To_Lower (V : Var_String) return Var_String;
procedure Translate_To_Upper (V : in out Var_String);
procedure Translate_To_Lower (V : in out Var_String);
private
type Var_String is record
Str : String (1..Max_Length);
Num : Integer range 0..Max_Length:=0;
end record;
Null_Var_String : constant Var_String :=
(Str => (others => ' '), Num => 0);
end Var_Strings;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Otras librerías estándares
Nombre
35
UNIVERSIDAD
DE CANTABRIA
Descripción
Ada.Numerics.Complex_Types
Tipos para números complejos
Ada.Numerics.
Complex_Elementary_Functions
Operaciones matemáticas para números complejos
Ada.Calendar
Fecha y hora
Ada.Characters.Handling
Conversión y clasificación de caracteres y strings
Ada.Characters.Latin_1
Conjunto de caracteres estándares
Ada.Command_Line
Operaciones para recibir los argumentos expresados en la orden de
ejecución del programa
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
36
3.7. Ejemplo de programa con
paquetes
UNIVERSIDAD
DE CANTABRIA
Programa para la gestión de una lista de alumnos
Fases:
• Análisis de requerimientos
• Especificación funcional
• Diseño arquitectónico
• Diseño detallado
• Codificación
• Prueba
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Análisis de requerimientos
37
UNIVERSIDAD
DE CANTABRIA
Queremos manejar datos personales de una clase de alumnos
Cada alumno tiene los siguientes datos:
• Nombre
• Teléfono
• Escuela a la que pertenece (dentro de un conjunto fijo)
La clase contiene un número variable de alumnos
• Podemos acotar el número máximo a 100
• No es necesario que estén ordenados
El programa debe permitir insertar alumnos nuevos y ver los datos
del alumno indicado por el usuario
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Especificación funcional
38
UNIVERSIDAD
DE CANTABRIA
El programa presentará al usuario un menú con tres opciones:
• Insertar un alumno nuevo
- comprueba si cabe; si no cabe presenta un error
- pedirá los datos del alumno por teclado
- insertará el nuevo alumno en la clase
• Mirar los datos de un alumno
- pedirá el número del alumno
- si es incorrecto muestra un mensaje de error
- si es correcto muestra los datos de ese alumno
• Salir del programa
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
39
Diseño arquitectónico
UNIVERSIDAD
DE CANTABRIA
Partimos el programa en las siguientes partes
• clase alumno
- datos: datos personales del alumno
- operaciones: para leer datos de teclado y escribirlos en pantalla
• clase "clase"
- datos: la lista de los alumnos
- operaciones: número de alumnos, saber si está llena, obtener el
alumno "n", insertar un nuevo alumno
• librería "menu"
- con operaciones para pedir una opción del menú, pedir el número
de un alumno, y mostrar un mensaje de error
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Diseño arquitectónico (cont.)
40
UNIVERSIDAD
DE CANTABRIA
• programa principal que gestiona las llamadas a las operaciones
de los diferentes paquetes
Las interfaces de cada parte se muestran a continuación:
package Alumnos is
type Tipo_Escuela is (Teleco, Caminos, Fisicas, Medicina);
type Alumno is private;
procedure Lee (Alu : out Alumno);
procedure Escribe (Alu : in Alumno);
private
...
end Alumnos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Diseño arquitectónico (cont.)
41
UNIVERSIDAD
DE CANTABRIA
with Alumnos;
package Clases is
Max_Alumnos
: constant Integer := 100;
subtype Num_Alumno is Integer range 1..Max_Alumnos;
type Clase is private;
procedure Inserta_Alumno
(Alu : in Alumnos.Alumno; La_Clase : in out Clase);
function Dame_Alumno
(Num : in Num_Alumno;
La_Clase : in Clase)
return Alumnos.Alumno;
function Numero_Alumnos (La_Clase : in Clase) return Natural;
function Llena (La_Clase : in Clase) return Boolean;
private
...
end Clases;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
42
Diseño arquitectónico (cont.)
UNIVERSIDAD
DE CANTABRIA
with Clases;
package Menu is
type Opcion is (Insertar,Mirar,Salir);
procedure Pide_Opcion (La_Opcion : out Opcion);
procedure Lee_Num_Alumno (Num : out Clases.Num_Alumno);
procedure Mensaje_Error (Mensaje : in String);
end Menu;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Diseño detallado
43
UNIVERSIDAD
DE CANTABRIA
Clase Alumno
• datos: registro con los siguientes campos:
nombre (string de hasta 20 caracteres)
número de caracteres del nombre
teléfono (string fijo de 9 caracteres)
escuela: dato enumerado
• leer datos de teclado
mostrar el nombre de cada dato y leerlo
• escribir datos en pantalla
mostrar el nombre de cada dato y su valor
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Diseño detallado (cont.)
44
UNIVERSIDAD
DE CANTABRIA
Clase Clase
• Estructura de la lista de los alumnos
- usaremos un array de alumnos y una variable para saber cuántos
alumnos hay
• número de alumnos
retornar el número almacenado
• saber si está llena
comparar el número de alumnos con el máximo
• obtener el alumno "n"
devolver la casilla n
• insertar un nuevo alumno
del array
añadirle al final del array e incrementar el nº de alumnos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
45
Diseño detallado (cont.)
UNIVERSIDAD
DE CANTABRIA
Librería Menu
• pedir una opción del menú
presentar todas las opciones con un número al lado
pedir un número
convertirlo al tipo enumerado Opcion
• pedir el número de un alumno
poner un texto y leer el número
• mostrar un mensaje de error
poner el texto en pantalla
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Diseño detallado (cont.)
46
UNIVERSIDAD
DE CANTABRIA
Programa principal. Pseudocódigo:
procedure Principal is
Tercero_B : Clase=Vacia
begin
loop
Pedir una opcion
case la opcion es
when insertar
si no cabe: mostrar error
si cabe:
pedir datos del alumno
insertar alumno
when mirar
pedir el numero
si es incorrecto mostrar error
si no, mostrar el alumno
when salir: finalizar
end loop;
end Principal
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Codificación: Paquete Alumnos
47
UNIVERSIDAD
DE CANTABRIA
package Alumnos is
Tamano_Nombre : constant Integer := 20;
type Tipo_Escuela is (Teleco, Caminos, Fisicas, Medicina);
type Alumno is private;
procedure Lee (Alu : out Alumno);
procedure Escribe (Alu : in Alumno);
private
type Alumno
Nombre
N_Nombre
Telefono
Escuela
end record;
end Alumnos;
is record
: String(1..Tamano_Nombre);
: Integer range 0..Tamano_Nombre:=0;
: String(1..9):="
";
: Tipo_Escuela:=Teleco;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
48
Paquete Alumnos (cont.)
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO;
use Ada.Text_IO;
package body Alumnos is
package Escuela_IO is new Enumeration_IO(Tipo_Escuela);
procedure Escribe (Alu : in Alumno) is
begin
Put_Line("--------------------------");
Put("Nombre
: ");
Put_Line(Alu.Nombre(1..Alu.N_Nombre));
Put_Line("Telefono : "&Alu.Telefono);
Put("Escuela : ");
Escuela_IO.Put(Alu.Escuela);
New_Line;
Put_Line("--------------------------");
New_Line;
end Escribe;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Alumnos (cont.)
49
UNIVERSIDAD
DE CANTABRIA
procedure Lee (Alu : out Alumno) is
begin
Put("Nombre del alumno: ");
Get_Line(Alu.Nombre,Alu.N_Nombre);
Put("Numero de Telefono: (9 cifras) ");
Get(Alu.Telefono);
Skip_Line;
Put("Escuela: ");
Escuela_IO.Get(Alu.Escuela);
Skip_Line;
end Lee;
end Alumnos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Clases
50
UNIVERSIDAD
DE CANTABRIA
with Alumnos;
package Clases is
Max_Alumnos
: constant Integer := 100;
subtype Num_Alumno is Integer range 1..Max_Alumnos;
type Clase is private;
procedure Inserta_Alumno
(Alu : in Alumnos.Alumno;
La_Clase : in out Clase);
function Dame_Alumno
(Num : in Num_Alumno;
La_Clase : in Clase)
return Alumnos.Alumno;
function Numero_Alumnos (La_Clase : in Clase) return Natural;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
51
Paquete Clases (cont.)
UNIVERSIDAD
DE CANTABRIA
function Llena (La_Clase : in Clase) return Boolean;
private
type Tipo_Alumnos is array (1..Max_Alumnos) of Alumnos.Alumno;
type Clase is record
Alumnos : Tipo_Alumnos;
Num
: Integer:=0;
end record;
end Clases;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Clases (cont.)
52
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO;
use Ada.Text_IO;
package body Clases is
function Dame_Alumno
(Num : in Num_Alumno;
La_Clase : in Clase)
return Alumnos.Alumno
is
begin
return La_Clase.Alumnos(Num);
end Dame_Alumno;
procedure Inserta_Alumno
(Alu : in Alumnos.Alumno; La_Clase : in out Clase)
is
begin
La_Clase.Num:=La_Clase.Num+1;
La_Clase.Alumnos(La_Clase.Num):=Alu;
end Inserta_Alumno;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Clases (cont.)
53
UNIVERSIDAD
DE CANTABRIA
function Llena (La_Clase : in Clase) return Boolean is
begin
return La_Clase.Num=Max_Alumnos;
end Llena;
function Numero_Alumnos (La_Clase : in Clase) return Natural is
begin
return La_Clase.Num;
end Numero_Alumnos;
end Clases;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
54
Paquete Menu
UNIVERSIDAD
DE CANTABRIA
with Clases;
package Menu is
type Opcion is (Insertar,Mirar,Salir);
procedure Pide_Opcion (La_Opcion : out Opcion);
procedure Lee_Num_Alumno (Num : out Clases.Num_Alumno);
procedure Mensaje_Error (Mensaje : in String);
end Menu;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Menu (cont.)
55
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO, Ada.Integer_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO;
package body Menu is
procedure Lee_Num_Alumno (Num : out Clases.Num_Alumno) is
begin
Put("Numero del alumno: ");
Get(Num);
Skip_Line;
end Lee_Num_Alumno;
procedure Mensaje_Error (Mensaje : in String) is
begin
Put_Line(Mensaje);
end Mensaje_Error;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Menu (cont.)
56
UNIVERSIDAD
DE CANTABRIA
procedure Pide_Opcion (La_Opcion : out Opcion) is
Num_Opcion : Integer range 1..3;
begin
New_Line;
Put_Line("LISTA DE ALUMNOS:");
Put_Line("1-Insertar alumno");
Put_Line("2-Mirar un alumno");
Put_Line("3-Salir");
Put("Elige una opcion:");
Get(Num_Opcion);
Skip_Line;
La_Opcion:=Opcion’Val(Num_Opcion-1);
end Pide_Opcion;
end Menu;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
57
Programa principal
UNIVERSIDAD
DE CANTABRIA
with Menu,Alumnos,Clases;
procedure Lista_Alumnos is
Tercero_B : Clases.Clase;
Eleccion
: Menu.Opcion;
Alu : Alumnos.Alumno;
Num : Clases.Num_Alumno;
begin
loop
Menu.Pide_Opcion (Eleccion);
case Eleccion is
when Menu.Insertar =>
if Clases.Llena(Tercero_B) then
Menu.Mensaje_Error("No caben mas alumnos");
else
Alumnos.Lee(Alu);
Clases.Inserta_Alumno(Alu,Tercero_B);
end if;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Programa principal (cont.)
58
UNIVERSIDAD
DE CANTABRIA
when Menu.Mirar =>
Menu.Lee_Num_Alumno(Num);
if Num>Clases.Numero_Alumnos(Tercero_B) then
Menu.Mensaje_Error("Alumno no existe");
else
Alu:=Clases.Dame_Alumno(Num,Tercero_B);
Alumnos.Escribe(Alu);
end if;
when Menu.Salir => exit;
end case;
end loop;
end Lista_Alumnos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Prueba
59
UNIVERSIDAD
DE CANTABRIA
La prueba se puede hacer en las siguientes fases:
• Paquete Alumnos: hacer un programa principal de prueba que
lea un alumno y lo muestre por la pantalla
• Paquete Menu: hacer un programa principal de prueba que
invoque cada operación y muestre el resultado obtenido
• Paquete Clases y programa principal: usar el programa
completo para probar las clases y el funcionamiento completo
- introducir varios alumnos
- mirarlos
- probar los dos errores definidos: llena (reduciendo temporalmente
el tamaño máximo) y número de alumno incorrecto
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
60
Criterios para la prueba de una unidad
UNIVERSIDAD
DE CANTABRIA
El programa de prueba de una unidad debe:
• probar todas las operaciones, con todos sus casos,
comparando los resultados con algún resultado conocido
• probar las operaciones en diferente orden (p.e. insertar,
eliminar, volver a insertar, etc.)
• probar los casos límite: p.e. estructura de datos llena, vacía,
insertar al principio o al final, etc.
• probar todos los casos de error que se pueda
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.8 Programación orientada a objetos
avanzada
61
UNIVERSIDAD
DE CANTABRIA
Un diseño orientado a objetos puede implementarse mediante un
lenguaje convencional (como C o Pascal). Sin embargo:
a) no hay un mecanismo para encapsular el objeto junto a sus
operaciones:
- para expresarlas en un mismo módulo independiente
- y especificar por separado la parte visible y los detalles internos o
partes privadas de un objeto
b) el software orientado al objeto sería más voluminoso, ya que si
los objetos se parecen, repetiremos mucho código
c) operaciones similares de objetos parecidos (denominadas
polimórficas) deben distinguirse en tiempo de compilación
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
El problema de la repetición de código
62
UNIVERSIDAD
DE CANTABRIA
Al crear un objeto parecido a otro debemos repetir los elementos
comunes
Lo ideal sería que:
• el nuevo objeto herede lo que tuviese el viejo: herencia
• programar sólo las diferencias
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
63
El problema del polimorfismo
UNIVERSIDAD
DE CANTABRIA
La palabra polimorfismo viene de “múltiples formas”
Las operaciones polimórficas son aquellas que hacen funciones
similares con objetos diferentes:
mover círculo:
borrar círculo
desplazar el centro
dibujar círculo
mover cuadrado:
borrar cuadrado
desplazar el centro
dibujar cuadrado
El problema es que debemos tratarlas de forma diferente
mover figura:
case figura is
when círculo => mover círculo
when cuadrado => mover cuadrado
...
end case
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
El problema del polimorfismo (cont.)
64
UNIVERSIDAD
DE CANTABRIA
Para hacer una operación similar con diferentes objetos sería
mejor expresarla de forma independiente del objeto usado:
• por ejemplo, para mover una figura sería más lógico programar
de una sóla vez:
mover figura:
borrar figura
desplazar el centro
dibujar figura
• además, esta forma funcionaría también con figuras definidas
en el futuro (es reutilizable)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Lenguajes para OOP
65
UNIVERSIDAD
DE CANTABRIA
Estas necesidades e inconvenientes se resuelven utilizando
lenguajes de programación orientada a objetos, que soportan:
a) encapsulamiento de los objetos y sus operaciones
b) extensión de objetos y herencia de sus operaciones
- se crean objetos a partir de otros, y se programan sólo las
diferencias
c) polimorfismo, que significa invocar una operación de una
familia de objetos parecidos; en tiempo de ejecución se elige la
operación apropiada al objeto concreto utilizado
- a esto se llama enlace tardío o enlace dinámico (“late binding” o
“dynamic binding”)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
66
Implementación de Objetos en Ada
UNIVERSIDAD
DE CANTABRIA
Encapsulado de objetos: mediante paquetes
Clases de objetos: tipos de datos abstractos y etiquetados,
declarados en un paquete, o en un paquete genérico
Objetos simples:
• variables de uno de los tipos anteriores, o un
• paquete que opere como máquina de estados abstracta
Operaciones de un objeto: subprogramas definidos en el paquete
donde se declara el objeto o la clase de objetos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Notas:
67
UNIVERSIDAD
DE CANTABRIA
Para poder hacer programación orientada al objeto es casi imprescindible contar con facilidades especiales
en el lenguaje. El lenguaje Ada presenta un soporte completo para programación orientada a objetos.
Las clases de objetos pueden representarse como tipos abstractos de datos. Si el objeto se va a extender
se declara como un tipo registro etiquetado. En Ada se pueden implementar como tipos de datos privados
declarados en la especificación de un paquete, en donde también se declaran todas las operaciones
asociadas a la clase de objetos.
Los tipos etiquetados se pueden extender para crear nuevos tipos de datos, que heredan los atributos y
operaciones del tipo anterior. Permiten también el polimorfismo.
Un objeto se puede implementar como una instancia (una variable) de una clase de objetos (un tipo).
También se puede implementar un objeto mediante un paquete que esté escrito en forma de máquina de
estados abstracta, pero en este caso no se puede extender sin modificar. Un paquete de este tipo presenta
en su especificación las operaciones (procedimientos y funciones) que el objeto puede sufrir. El estado del
objeto se declara (mediante variables) en el cuerpo, o parte no visible. Las operaciones del objeto modifican
el estado.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.9. Tipos etiquetados
68
UNIVERSIDAD
DE CANTABRIA
Contienen los atributos de la clase. Declaración:
type Una_Clase is tagged record
atributo1 : tipo1;
atributo2 : tipo2;
end record;
Es habitual hacer los atributos privados
package Nombre_Paquete is
type Una_Clase is tagged private;
-- operaciones de la clase
private
type Una_Clase is tagged record
atributo1 : tipo1;
atributo2 : tipo2;
end record;
end Nombre_Paquete;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
69
Operaciones primitivas
UNIVERSIDAD
DE CANTABRIA
Los métodos de la clase se llaman operaciones primitivas
• Tienen un parámetro del tipo etiquetado
• Están escritas inmediatamente a continuación del tipo
etiquetado
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.10. Extensión de tipos etiquetados
mediante la Herencia
70
UNIVERSIDAD
DE CANTABRIA
Declaración de un tipo extendido:
type Clase_Nueva is new Una_Clase with record
atributo3 : tipo3;
atributo4 : tipo4;
end record;
El nuevo tipo
• también es etiquetado
• hereda todos los atributos del viejo, y añade otros
Si no se desea añadir nuevos:
type Clase_Nueva is new Una_Clase with null record;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Extensión de tipos etiquetados (cont.)
71
UNIVERSIDAD
DE CANTABRIA
La extensión puede ser con atributos privados:
with Nombre_Paquete; use Nombre_Paquete;
package Nuevo_Paquete is
type Clase_Nueva is new Una_Clase with private;
-- operaciones de la clase nueva
private
type Clase_Nueva is new Una_Clase with record
atributo3 : tipo3;
atributo4 : tipo4;
end record;
end Nuevo_Paquete;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
72
Herencia de operaciones primitivas
UNIVERSIDAD
DE CANTABRIA
Al extender una clase
• se heredan todas las operaciones primitivas del padre
• se puede añadir nuevas operaciones primitivas
La nueva clase puede elegir:
• redefinir la operación: se vuelve a escribir
- la nueva operación puede usar la del padre y hacer más cosas:
programación incremental
- o puede ser totalmente diferente
• dejarla como está
- en este caso, no escribir nada
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Invocar las operaciones del padre
73
UNIVERSIDAD
DE CANTABRIA
Para usar una operación del padre del objeto, se hace un cambio
de punto de vista sobre ese objeto
• Ejemplo: si definimos
O : Clase_Nueva;
• El cambio de punto de vista es como un cambio de tipo:
Una_Clase(O)
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.11. Ejemplo de Herencia: Figuras
74
UNIVERSIDAD
DE CANTABRIA
package Figuras is
type Coordenadas is record
X,Y : Float;
end record;
type Figura is tagged record
Centro : Coordenadas;
end record;
procedure Dibuja (F : Figura);
procedure Borra (F : Figura);
function Esta_Centrada (F : Figura) return Boolean;
end Figuras;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
75
Figuras (cont.)
UNIVERSIDAD
DE CANTABRIA
with Figuras; use Figuras;
package Circulos is
type Circulo is new Figura with record
Radio : Float;
end record;
procedure Dibuja (C : Circulo); -- redefinida
procedure Borra (C : Circulo); -- redefinida
-- hereda Esta_Centrada
end Circulos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Figuras (cont.)
76
UNIVERSIDAD
DE CANTABRIA
with Figuras; use Figuras;
package Rectangulos is
type Rectangulo is new Figura with record
Ancho, Alto : Float;
end record;
procedure Dibuja (R : Rectangulo); -- redefinida
procedure Borra (R : Rectangulo); -- redefinida
-- hereda Esta_Centrada
end Rectangulos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Figuras (cont.)
77
UNIVERSIDAD
DE CANTABRIA
Ejemplo de invocación de las operaciones:
• si tenemos definido un rectángulo por ejemplo
with Rectangulos;
...
R : Rectangulos.Rectangulo;
• las dos invocaciones siguientes son equivalentes
Rectangulos.Dibuja(R); -- estilo Ada 95
R.Dibuja;
-- añadido en Ada 2005
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
78
Notas:
UNIVERSIDAD
DE CANTABRIA
En este ejemplo el tipo “Figura” es un registro etiquetado, y por tanto extensible. Tiene definidas tres
operaciones primitivas (las operaciones primitivas son las que se definen inmediatamente a continuación
del tipo y que tienen al menos un parámetro de ese tipo): Dibuja, Borra, y Esta_Centrada.
Se han hecho dos extensiones del tipo Figura: Círculo y Rectángulo. Ambas extensiones heredan las tres
operaciones primitivas de la Figura. Sin embargo las operaciones Dibuja y Borra no les sirven (porque son
diferentes para las figuras, los círculos, y los rectángulos), y por ello las redefinen. La operación
Esta_Centrada se hereda, lo que significa que, sin tener que declararlas, existen las dos nuevas funciones
siguientes:
function Esta_Centrada (F : Círculo) return Boolean;
function Esta_Centrada (F : Rectángulo) return Boolean;
Estas funciones tienen el mismo cuerpo (las mismas declaraciones e instrucciones) que la original.
Las extensiones (Círculo y Rectángulo) podrían declarar nuevas operaciones primitivas, y podrían a su vez
extenderse.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.12. Tipos etiquetados abstractos y
privados
79
UNIVERSIDAD
DE CANTABRIA
El tipo Figura del ejemplo anterior no representa ninguna figura
concreta
• existe sólo como padre de la jerarquía
Se podría definir como abstracto
• no se permite crear objetos
• pueden tener operaciones primitivas abstractas (sin cuerpo),
- será obligatorio redefinirlas en los hijos no abstractos
El tipo etiquetado puede tener sus atributos privados
• en ese caso hacen falta operaciones para cambiarlos y usarlos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Figuras abstractas
80
UNIVERSIDAD
DE CANTABRIA
package Figuras_Abstractas is
type Coordenadas is record
X,Y : Float;
end record;
type Figura is abstract tagged record
Centro : Coordenadas;
end record;
procedure Dibuja (F : Figura) is abstract;
procedure Borra (F : Figura) is abstract;
function Esta_Centrada (F : Figura) return Boolean;
end Figuras_Abstractas;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
81
Figuras con atributos privados
UNIVERSIDAD
DE CANTABRIA
package Figuras_Privadas is
type Coordenadas is record
X,Y : Float;
end record;
type Figura is abstract tagged private;
procedure Cambia_Centro
(F : in out Figura;
Nuevo_Centro : Coordenadas);
procedure Dibuja (F : Figura) is abstract;
procedure Borra (F : Figura) is abstract;
function Esta_Centrada (F : Figura) return Boolean;
private
type Figura is abstract tagged record
Centro : Coordenadas;
end record;
end Figuras_Privadas;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Figuras con atributos privados (cont.)
82
UNIVERSIDAD
DE CANTABRIA
package Figuras_Privadas.Circulos is
type Circulo is new Figura with private;
procedure Dibuja (C : Circulo); -- redefinida
procedure Borra (C : Circulo); -- redefinida
procedure Cambia_Radio
--nueva
(C : in out Circulo;
Nuevo_Radio : Float);
-- hereda Esta_Centrada y Cambia_Centro
private
type Circulo is new Figura with record
Radio : Float;
end record;
end Figuras_Privadas.Circulos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.13 Polimorfismo
83
UNIVERSIDAD
DE CANTABRIA
Para cada tipo etiquetado existe un tipo de “ámbito de clase”:
• identifica los objetos de ese tipo etiquetado
• y todos sus descendientes
Declaración:
Figura’class
-- Incluye a Figura, Circulo, Rectangulo,
-- y los que se definan después
Existen también punteros de ámbito de clase
type Figura_Ref is access Figura’class;
Las llamadas a operaciones primitivas en las que se usan tipos o
punteros de ámbito de clase son polimórficas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
84
Ejemplo de polimorfismo:
Figuras
UNIVERSIDAD
DE CANTABRIA
with Figuras;
use Figuras;
procedure Mueve (F : in out Figura’Class; A : in Coordenadas) is
begin
Borra(F); -- no se sabe a priori a cuál de las
-- operaciones de borrar se invocará
F.Centro:=A;
Dibuja(F);-- no se sabe a priori a cuál de las
-- operaciones de dibujar se invocará
end Mueve;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3.14. Programación Incremental
85
UNIVERSIDAD
DE CANTABRIA
El siguiente ejemplo muestra el concepto de la programación
incremental
- al extender el programa, se programan sólo las diferencias
- añadir una nueva variante no implica modificación del código
original
El ejemplo es parte del código necesario para escribir un
simulador lógico sencillo para circuitos combinacionales
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Paquete Nudos
86
UNIVERSIDAD
DE CANTABRIA
package Nudos is
Max_Nudos : constant Integer:=100;
type Valor_Logico is range 0..1;
-- El tipo Nudo representa un nudo lógico de un circuito
type Nudo is range 1..Max_Nudos;
procedure Cambia_Valor(N : Nudo; Nuevo : Valor_Logico);
function Valor(N : Nudo) return Valor_Logico;
-- Pone en pantalla el nudo y su valor lógico
procedure Put_Nudo(N : Nudo);
-- El paquete permite saber si ha habido algún cambio
procedure Resetea_Cambios;
function Hay_Cambios return Boolean;
end Nudos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
87
Ejemplo: Paquete Puertas
UNIVERSIDAD
DE CANTABRIA
with Nudos; use Nudos;
package Puertas is
subtype Nombre_Puerta is String(1..4);
subtype Id_Puerta is String(1..9);
-- Puerta abstracta
type Puerta is abstract tagged private;
procedure Pon_Nudo_Salida
(P : in out Puerta;
N : in Nudo);
procedure Pon_Nombre
(P : in out Puerta;
Nombre : Nombre_Puerta);
procedure Imprime (P : Puerta);
function Identificador (P : Puerta) return Id_Puerta
is abstract;
procedure Opera (P : Puerta) is abstract;
type Puerta_Ref is access all Puerta’Class;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
88
UNIVERSIDAD
DE CANTABRIA
-- Inversor
type Inversor is new Puerta with private;
procedure Pon_Nudo_Entrada
(P : in out Inversor;
N : in Nudo);
procedure Imprime (P : Inversor);
function Identificador (P : Inversor) return Id_Puerta;
procedure Opera (P : Inversor);
type Inversor_Ref is access all Inversor’Class;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
89
UNIVERSIDAD
DE CANTABRIA
-- Puerta de dos entradas, abstracta
type Puerta_Dos_Entradas is abstract new Puerta with private;
procedure Pon_Nudos_Entrada
(P : in out Puerta_Dos_Entradas;
N1,N2 : in Nudo);
procedure Imprime (P : Puerta_Dos_Entradas);
-- Puerta AND de dos entradas
type Puerta_And_2 is new Puerta_Dos_Entradas with private;
function Identificador (P : Puerta_And_2) return Id_Puerta;
procedure Opera (P : Puerta_And_2);
type Puerta_And_2_Ref is access all Puerta_And_2’class;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
90
Ejemplo: Puertas (cont.)
UNIVERSIDAD
DE CANTABRIA
-- Puerta OR de dos entradas
type Puerta_Or_2 is new Puerta_Dos_Entradas with private;
function Identificador (P : Puerta_Or_2) return Id_Puerta;
procedure Opera (P : Puerta_Or_2);
type Puerta_Or_2_Ref is access all Puerta_Or_2’class;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
91
UNIVERSIDAD
DE CANTABRIA
private
type Puerta is abstract tagged record
Nombre : Nombre_Puerta:="
";
Nudo_Salida : Nudo;
end record;
type Inversor is new Puerta with record
Nudo_Entrada : Nudo;
end record;
type Puerta_Dos_Entradas is abstract new Puerta with record
Nudo_Entrada_1, Nudo_Entrada_2 : Nudo;
end record;
type Puerta_And_2 is new Puerta_Dos_Entradas with null record;
type Puerta_Or_2 is new Puerta_Dos_Entradas with null record;
end Puertas;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
92
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO; use Ada.Text_IO;
package body Puertas is
procedure Pon_Nudo_Salida
(P : in out Puerta;
N : in Nudo)
is
begin
P.Nudo_Salida:=N;
end Pon_Nudo_Salida;
procedure Pon_Nombre
(P : in out Puerta;
Nombre : Nombre_Puerta)
is
begin
P.Nombre:=Nombre;
end Pon_Nombre;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
93
Ejemplo: Puertas (cont.)
UNIVERSIDAD
DE CANTABRIA
procedure Imprime (P : Puerta) is
begin
-- Escribimos la parte común a todas las puertas
-- Empezamos por el identificador
Put(Identificador(Puerta’Class(P)));
-- el ámbito de clase hace que la llamada sea polimórfica
Set_Col(11);
-- Ahora el nudo de salida
Put_Nudo(P.Nudo_Salida);
Set_Col(16);
end Imprime;
procedure Pon_Nudo_Entrada
(P : in out Inversor;
N : in Nudo)
is
begin
P.Nudo_Entrada:=N;
end Pon_Nudo_Entrada;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
94
UNIVERSIDAD
DE CANTABRIA
procedure Imprime (P : Inversor) is
begin
Imprime(Puerta(P)); -- hemos invocado la operación del padre
Put_Nudo(P.Nudo_Entrada);
New_Line;
end Imprime;
function Identificador (P : Inversor) return Id_Puerta is
begin
return "INV "&P.Nombre;
end Identificador;
procedure Opera (P : Inversor) is
begin
if Valor(P.Nudo_Entrada)=0 then
Cambia_Valor(P.Nudo_Salida,1);
else
Cambia_Valor(P.Nudo_Salida,0);
end if;
end Opera;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
95
UNIVERSIDAD
DE CANTABRIA
procedure Imprime (P : Puerta_Dos_Entradas) is
begin
Imprime(Puerta(P)); -- hemos invocado la operación del padre
-- Ahora escribimos los dos nudos de entrada
Put_Nudo(P.Nudo_Entrada_1);
Set_Col(22);
Put_Nudo(P.Nudo_Entrada_2);
New_Line;
end Imprime;
procedure Pon_Nudos_Entrada
(P : in out Puerta_Dos_Entradas;
N1,N2 : in Nudo)
is
begin
P.Nudo_Entrada_1:=N1;
P.Nudo_Entrada_2:=N2;
end Pon_Nudos_Entrada;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
96
Ejemplo: Puertas (cont.)
UNIVERSIDAD
DE CANTABRIA
function Identificador (P : Puerta_And_2) return Id_Puerta is
begin
return "AND2 "&P.Nombre;
end Identificador;
procedure Opera (P : Puerta_And_2) is
begin
if Valor(P.Nudo_Entrada_1)=1 and then
Valor(P.Nudo_Entrada_2)=1
then
Cambia_Valor(P.Nudo_Salida,1);
else
Cambia_Valor(P.Nudo_Salida,0);
end if;
end Opera;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Puertas (cont.)
97
UNIVERSIDAD
DE CANTABRIA
function Identificador (P : Puerta_Or_2) return Id_Puerta is
begin
return "OR2 "&P.Nombre;
end Identificador;
procedure Opera (P : Puerta_Or_2) is
begin
if Valor(P.Nudo_Entrada_1)=1 or else
Valor(P.Nudo_Entrada_2)=1
then
Cambia_Valor(P.Nudo_Salida,1);
else
Cambia_Valor(P.Nudo_Salida,0);
end if;
end Opera;
end Puertas;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Paquete Circuitos
98
UNIVERSIDAD
DE CANTABRIA
with Puertas; use Puertas;
package Circuitos is
Max_Puertas : Integer:=100;
type Circuito is tagged private;
procedure Anade_Puerta
(C : in out Circuito;
P : Puerta_Ref);
-- puede elevar No_Cabe
procedure Imprime (C : Circuito);
-- Imprime todas las puertas del circuito
procedure Opera (C : Circuito);
-- Opera con todas las puertas; puede elevar No_Converge
No_Cabe,No_Converge : exception;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
99
Ejemplo: Circuitos (cont.)
UNIVERSIDAD
DE CANTABRIA
private
type Lista_Puertas is array(1..Max_Puertas) of Puerta_Ref;
type Circuito is tagged record
Puertas : Lista_Puertas;
Num : Integer range 0..Max_Puertas:=0;
end record;
end Circuitos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Circuitos (cont.)
100
UNIVERSIDAD
DE CANTABRIA
with Nudos; use Nudos;
package body Circuitos is
procedure Anade_Puerta
(C : in out Circuito; P : Puerta_Ref)
is
begin
if C.Num=Max_Puertas then
raise No_Cabe;
end if;
C.Num:=C.Num+1;
C.Puertas(C.Num):=P;
end Anade_Puerta;
procedure Imprime (C : Circuito) is
begin
for I in 1..C.Num loop
Imprime(C.Puertas(I).all);
end loop;
end Imprime;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Circuitos (cont.)
101
UNIVERSIDAD
DE CANTABRIA
procedure Opera (C : Circuito) is
begin
-- limitamos el número de veces por si hay realimentación
for Veces in 1..Max_Nudos loop
Resetea_Cambios;
-- operamos con todas las puertas
for I in 1..C.Num loop
Opera(C.Puertas(I).all);
end loop;
-- terminamos si no ha habido cambios de valores lógicos
if not Hay_Cambios then
return;
end if;
end loop;
-- se ha excedido el máximo número de veces
raise No_Converge;
end Opera;
end Circuitos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
102
Ejemplo: Programa principal
UNIVERSIDAD
DE CANTABRIA
with Puertas, Circuitos, Nudos;
use Puertas, Circuitos, Nudos;
procedure Simulador_Logico is
C : Circuito;
Inv : Inversor_Ref;
And2 : Puerta_And_2_Ref;
Or2 : Puerta_Or_2_Ref;
begin
-- Crear una puerta AND2
And2:=new Puerta_And_2;
Pon_Nombre(And2.all,"A
");
Pon_Nudo_Salida(And2.all,5);
Pon_Nudos_Entrada(And2.all,1,2);
Anade_Puerta(C,Puerta_Ref(And2));
-- Crear otras puertas de forma similar
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Programa principal
103
UNIVERSIDAD
DE CANTABRIA
-- Poner los valores de las entradas
Cambia_Valor(1,0);
Cambia_Valor(2,1);
Cambia_Valor(3,1);
Cambia_Valor(4,0);
-- Calcular las salidas e imprimir resultados
Opera(C);
Imprime(C);
end Simulador_Logico;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Añadir una nueva variante
104
UNIVERSIDAD
DE CANTABRIA
package Puertas.Nand2 is
-- Puerta NAND de dos entradas -type Puerta_Nand_2 is new Puerta_Dos_Entradas with private;
function Identificador (P : Puerta_Nand_2) return Id_Puerta;
procedure Opera (P : Puerta_Nand_2);
type Puerta_Nand_2_Ref is access all Puerta_Nand_2’class;
private
type Puerta_Nand_2 is new Puerta_Dos_Entradas with null record;
end Puertas.Nand2;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
105
Ejemplo: Añadir una nueva variante
(cont.)
UNIVERSIDAD
DE CANTABRIA
package body Puertas.Nand2 is
function Identificador (P : Puerta_Nand_2) return Id_Puerta is
begin
return "NAD2 "&P.Nombre;
end Identificador;
procedure Opera (P : Puerta_Nand_2) is
begin
if Valor(P.Nudo_Entrada_1)=1 and then
Valor(P.Nudo_Entrada_2)=1
then
Cambia_Valor(P.Nudo_Salida,0);
else
Cambia_Valor(P.Nudo_Salida,1);
end if;
end Opera;
end Puertas.Nand2;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Resumen
106
UNIVERSIDAD
DE CANTABRIA
Ventajas de la Programación Incremental:
• es más simple de entender (ya que cada variante está aparte)
• la estructura del código es mucho más simple (no hay variantes
o instrucciones case anidadas
• es extensible sin modificar el código existente, sin recompilarlo,
y sin posibilidad de añadirle errores
Desventajas
• es necesario pensar siempre en la extensibilidad: hay que
acordarse de hacer enlazado dinámico si es necesario
• el código fuente está distribuido en diferentes módulos y
subprogramas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
107
Parte I: Fundamentos de programación
en lenguaje Ada
UNIVERSIDAD
DE CANTABRIA
1. Elementos básicos del lenguaje
2. Estructuras de datos dinámicas
3. Modularidad y programación orientada a objetos
4. Tratamiento de errores
5. Abstracción de tipos mediante unidades genéricas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.1. Excepciones
1
UNIVERSIDAD
DE CANTABRIA
Representan circunstancias anormales o de error
Ventajas de este mecanismo:
• El código de la parte errónea del programa está separado del de
la parte correcta
• Si se te olvida tratar una excepción, te das cuenta al probar el
programa, porque éste se detiene
• Se puede pasar la gestión del error de un módulo a otro de modo
automático
- agrupar la gestión del error en el lugar más apropiado
Las excepciones pueden ser predefinidas, o definidas por el
usuario
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.2. Excepciones predefinidas
2
UNIVERSIDAD
DE CANTABRIA
En el lenguaje:
• Constraint_Error : variable fuera de rango, índice de array
fuera de rango, uso de un puntero nulo para acceder a un dato,
etc.
• Program_Error: programa erróneo o mal construido; por
ejemplo, ocurre si una función se acaba sin haber ejecutado su
instrucción return. No se trata.
• Storage_Error: Memoria agotada. Ocurre tras una operación
new, o al llamar a un procedimiento si no hay espacio en el stack.
• Tasking_Error: Error con las tareas concurrentes
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3
Excepciones predefinidas (cont.)
UNIVERSIDAD
DE CANTABRIA
En librerías estándares hay muchas
Un par de ellas que son frecuentes:
• Ada.Numerics.Argument_Error: Error con un argumento de
las funciones elementales (p.e., raíz cuadrada de un número
negativo)
• Ada.Text_IO.Data_Error: Formato de dato leído es
incorrecto
- p.e., si se leen letras pero se pretende leer un entero
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.3. Declaración de excepciones
propias
4
UNIVERSIDAD
DE CANTABRIA
Las excepciones definidas por el usuario se declaran como
variables especiales, del tipo exception
nombre : exception;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.4. Elevar y tratar excepciones
5
UNIVERSIDAD
DE CANTABRIA
Las excepciones se elevan, para indicar que ha habido un error:
• las predefinidas se elevan automáticamente
• las definidas por el usuario se elevan mediante la instrucción
raise:
raise nombre_excepcion;
Una excepción que se ha elevado, se puede tratar
• Esto significa, ejecutar un conjunto de instrucciones apropiado
a la gestión del error que la excepción representa
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
6
4.5. Manejadores de excepciones
UNIVERSIDAD
DE CANTABRIA
Se hace dentro de un bloque:
encabezamiento
declaraciones
begin
instrucciones
exception
manejadores
end;
Los manejadores gestionan las excepciones que se producen en
las instrucciones del bloque
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Manejadores de excepción
7
UNIVERSIDAD
DE CANTABRIA
Los manejadores se escriben así:
when Nombre_Excepcion =>
instrucciones;
Se pueden agrupar varias excepciones en el mismo manejador
when excepcion1 | excepcion2 | excepcion3 =>
instrucciones;
Se pueden agrupar todas las excepciones no tratadas en un único
manejador final
when others =>
instrucciones;
• es peligroso ya que puede que el tratamiento no sea adecuado
a la excepción que realmente ocurre
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.6. Funcionamiento de las
excepciones
8
UNIVERSIDAD
DE CANTABRIA
Cuando una excepción se eleva en un bloque:
a) Si hay un manejador:
• se abandonan las restantes instrucciones del bloque
• se ejecuta el manejador
• se continúa por el siguiente bloque en la secuencia de programa
b) Si no hay manejador
• se abandona el bloque
• se eleva la misma excepción en el siguiente bloque en la
secuencia del programa
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
9
Funcionamiento de las excepciones
(cont.)
UNIVERSIDAD
DE CANTABRIA
El siguiente bloque en la secuencia es:
• para un subprograma, el lugar posterior a la llamada
• para un bloque interno (declare-begin-end) la instrucción
siguiente al end
• para el programa principal, nadie
- el programa se detiene con un mensaje de error
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Creación de bloques para tratar
excepciones
10
UNIVERSIDAD
DE CANTABRIA
Si se desea continuar ejecutando las instrucciones de un bloque
donde se lanza una excepción, es preciso crear un bloque más
interno:
begin
begin
-- del bloque interno
instrucciones que pueden fallar
exception
manejadores
end;
-- del bloque interno
instrucciones que es preciso ejecutar, aunque haya fallo
end;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.7. Formas más habituales de tratar
excepciones
11
UNIVERSIDAD
DE CANTABRIA
Dependen de la gravedad del error
• a) ignorar
• b) indicar el error y luego seguir
• c) reintentar la operación (sólo si el error es recuperable)
• d) abandonar la operación
A continuación veremos ejemplos de cada una
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
12
a) Ignorar
UNIVERSIDAD
DE CANTABRIA
Escribir una operación, Pon_Mensaje_Doble, que pone un
mensaje en el terminal normal, y en un terminal remoto.
Para el terminal remoto existe el paquete:
package Terminal_Remoto is
procedure Pon_Mensaje (Str : String);
No_Conectado : exception;
end Terminal_Remoto;
Pon_Mensaje eleva No_Conectado si el terminal no está
conectado.
Pon_Mensaje_Doble debe ignorar este error si se produce, pero
siempre escribir el mensaje en el terminal principal
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Implementación
13
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Terminal_Remoto;
procedure Pon_Mensaje_Doble (Str : String) is
begin
Ada.Text_IO.Put_Line(Str);
Terminal_Remoto.Pon_Mensaje(Str);
exception
when Terminal_Remoto.No_Conectado =>
null; -- para no hacer nada hay que decirlo
end Pon_Mensaje_Doble;
Observar que si no se pone manejador, en lugar de ignorar la
excepción ésta se eleva en el siguiente bloque
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
b) Indicar el error
14
UNIVERSIDAD
DE CANTABRIA
Se desea escribir una operación para mostrar los datos de un
alumno, extrayéndolos de una lista
with Alumnos; -- lugar donde se declara el tipo Alumno
package Listas is
type Lista is private;
procedure Busca_Alumno(Al : in out Alumnos.Alumno;
L : in Lista);
procedure Inserta_Alumno(Al : in Alumno; L : in out Lista);
...
No_encontrado : exception;
No_Cabe : exception;
end Listas;
Busca_Alumno busca el alumno por el nombre, y eleva
No_Encontrado si no lo encuentra
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
15
Implementación
UNIVERSIDAD
DE CANTABRIA
El tipo Alumno contiene el nombre y datos personales del alumno
with Ada.Text_IO,Listas,Alumnos;
procedure Muestra_Alumno(L : Lista) is
Al : Alumnos.Alumno;
begin
Leer Al.nombre;
Listas.Busca_Alumno(Al,L);
Muestra datos del alumno;
exception
when Listas.No_Encontrado =>
Ada.Text_IO.Put_Line("Alumno no encontrado");
end Muestra_Alumno;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Comentarios
16
UNIVERSIDAD
DE CANTABRIA
Las instrucciones correspondientes a “mostrar los datos del
alumno” se saltan si hay un error
• eso es lo que se desea
En el código, quedan claramente separadas las instrucciones
normales, de las que corresponden al caso con error
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
c) Reintentar
17
UNIVERSIDAD
DE CANTABRIA
Un caso típico de operación que se reintenta es la lectura errónea
de datos del teclado
Se desea escribir un procedimiento para leer un entero
• primero pone un mensaje en la pantalla
• si la lectura falla, se reintenta
• si el entero no está comprendido entre un límite inferior y un
límite superior, se reintenta
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
18
Implementación
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_Io,Ada.Integer_Text_Io;
use Ada.Text_Io,Ada.Integer_Text_Io;
procedure Lee_Entero (Mensaje
: in String;
Num
: out Integer;
Lim_Inf, Lim_Sup : in Integer) is
I : Integer range Lim_Inf..Lim_Sup;
begin
loop
begin
Put(Mensaje);
Get(I);
Skip_Line;
Num:=I;
exit;
exception
when Constraint_Error | Data_Error =>
Skip_Line; Put_Line("Error al leer");
end;
end loop;
end Lee_Entero;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Programa de prueba
19
UNIVERSIDAD
DE CANTABRIA
with Lee_Entero;
procedure Prueba_Entero is
I : Integer range 2..20;
begin
for J in 1..5 loop
Lee_Entero("entero : ",I,2,20);
-- no hace falta tratar Constraint_Error ni Data_Error,
-- pues ya están tratadas dentro de Lee_Entero
end loop;
end Prueba_Entero;
Comentarios
• creamos un tipo entero con el rango deseado, para que se eleve
Constraint_Error automáticamente si estamos fuera de
límites
• vale el mismo manejador para las dos excepciones
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
d) Abandonar
20
UNIVERSIDAD
DE CANTABRIA
Creamos una operación para leer los datos de un alumno y luego
insertarlo en una lista del paquete Listas anterior
Inserta_Alumno eleva No_Cabe si el alumno no cabe
La operación nueva debe abandonarse si ocurre el error, pero
debe notificar este error al programa principal
• elevaremos para ello la misma excepción
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
21
Implementación
UNIVERSIDAD
DE CANTABRIA
with Ada.Text_IO,Listas,Alumnos;
procedure Nuevo_Alumno(L : Lista) is
Al : Alumnos.Alumno;
begin
Leer todos los datos de Al;
Listas.Inserta_Alumno(Al,L);
Muestra confirmación de los datos insertados;
exception
when Listas.No_Cabe =>
Ada.Text_IO.Put_Line("Alumno no cabe");
raise;
end Nuevo_Alumno;
Comentarios
• La instrucción raise “a secas” eleva la misma excepción que
se produjo
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
4.8. Paquete Ada.Exceptions (1/2)
22
UNIVERSIDAD
DE CANTABRIA
package Ada.Exceptions is
type Exception_Id is private;
Null_Id : constant Exception_Id;
function Exception_Name
(X : Exception_Id) return String;
type Exception_Occurrence is
limited private;
function Exception_Message
(X : Exception_Occurrence)
return String;
function Exception_Identity
(X : Exception_Occurrence)
return Exception_Id;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquete Ada.Exceptions (2/2)
23
UNIVERSIDAD
DE CANTABRIA
function Exception_Name
(X : Exception_Occurrence)
return String;
function Exception_Information
(X : Exception_Occurrence)
return String;
...
private
...
end Ada.Exceptions;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
24
Ejemplo de uso de Ada.Exceptions
(1/2)
UNIVERSIDAD
DE CANTABRIA
with Ada.Exceptions,Ada.Text_Io;
use Ada.Exceptions,Ada.Text_Io;
procedure Prueba_Exceptions is
procedure Eleva_Excepcion is
Opcion : Character;
begin
-- permite simular una excepción
Put_Line("1-elevar Constraint_Error");
Put_Line("2-elevar Data_Error");
Put_Line("3-elevar Storage_Error");
Put("Introduce opcion : ");
Get(Opcion); Skip_Line;
case Opcion is
when '1'=> raise Constraint_Error;
when '2'=> raise Data_Error;
when '3'=> raise Storage_Error;
when others => null;
end case;
end Eleva_Excepcion;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo de uso de Ada.Exceptions
(2/2)
25
UNIVERSIDAD
DE CANTABRIA
Car : Character;
begin -- de prueba_exceptions
loop
begin
-- acciones normales a repetir
Eleva_Excepcion;
exception
when Error : others =>
Put_Line("Se ha elevado "&Exception_Name(Error));
Put_Line("Mensaje
: "&Exception_Message(Error));
Put_Line("Información : "&Exception_Information(Error));
New_Line;
Put("¿Desea continuar el programa? (s/n)");
Get(Car); Skip_Line;
exit when Car/='S' and Car/='s';
end;
end loop;
end Prueba_Exceptions;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
26
Parte I: Fundamentos de programación
en lenguaje Ada
UNIVERSIDAD
DE CANTABRIA
1. Elementos básicos del lenguaje
2. Estructuras de datos dinámicas
3. Modularidad y programación orientada a objetos
4. Tratamiento de errores
5. Abstracción de tipos mediante unidades genéricas
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD
DE CIENCIAS
1
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
5.1. Introducción
1
UNIVERSIDAD
DE CANTABRIA
La abstracción de tipos es un requisito esencial para escribir
software reutilizable.
Se puede implementar en Ada mediante módulos genéricos:
• El módulo genérico es una plantilla en la que unos parámetros
genéricos quedan indeterminados.
• Los parámetros genéricos pueden ser tipos de datos, valores,
subprogramas, y paquetes.
• Un módulo genérico puede ser un procedimiento, función, o
paquete.
• Para usar un módulo genérico éste debe instanciarse, indicando
qué parámetros concretos se usarán.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo
2
UNIVERSIDAD
DE CANTABRIA
package Conjuntos is
subtype Elemento is String(1..20);
type Conjunto is private;
function Vacio return Conjunto;
procedure Inserta (E : Elemento;
C : in out Conjunto);
procedure Extrae (E : Elemento;
C : in out Conjunto);
-- pertenencia
function "<" (E: Elemento; C: Conjunto) return Boolean;
function "+" (X,Y : Conjunto) return Conjunto; -- Unión
function "*" (X,Y : Conjunto) return Conjunto; -- Intersección
function "-" (X,Y : Conjunto) return Conjunto; -- Diferencia
function "<" (X,Y : Conjunto) return Boolean; -- Inclusión
No_Cabe : exception;
private
Max_Elementos : constant Integer:=100;
type Conjunto is ...;
end Conjuntos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
3
Comentarios sobre el ejemplo
UNIVERSIDAD
DE CANTABRIA
• Para hacer un conjunto de otro tipo de datos, hay que reescribir
el paquete, cambiando el tipo Elemento
• Si el tipo Elemento está declarado en un paquete externo y se
desea hacer conjuntos de dos o más tipos diferentes, también
será necesaria la modificación del módulo.
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
5.2. Paquetes Genéricos
4
UNIVERSIDAD
DE CANTABRIA
La solución para hacer los conjuntos independientes del tipo
“Elemento” es la utilización de paquetes genéricos:
generic
type Elemento is private;
package Conjuntos is
type Conjunto is private;
-- todo igual que antes
end Conjuntos;
Para usar esta unidad es preciso instanciarla, indicando el tipo de
dato que se va a usar
package Conjuntos_Reales is new Conjuntos (Float);
package Conjuntos_Enteros is new Conjuntos (Integer);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Paquetes genéricos (cont.)
5
UNIVERSIDAD
DE CANTABRIA
La unidad genérica Conjuntos es reutilizable
• es independiente del tipo de dato almacenado
Un módulo genérico también se puede hacer independiente de un
valor.
• Por ejemplo, el módulo anterior tenía una limitación de 100
elementos
• Esta limitación se puede eliminar del siguiente modo:
generic
Max_Elementos : Integer;
type Elemento is private;
package Conjuntos is
-- igual que antes, sin la constante Max_Elementos
end Conjuntos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
6
Paquetes genéricos (cont.)
UNIVERSIDAD
DE CANTABRIA
La declaración de esta unidad para 500 números reales y para 300
números enteros:
package Conjuntos_Reales is new Conjuntos (500,Float);
package Conjuntos_Enteros is new Conjuntos (300,Integer);
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
5.3. Subprogramas genéricos
7
UNIVERSIDAD
DE CANTABRIA
Los subprogramas genéricos necesitan una especificación
separada del cuerpo
Especificación (fichero intercambia.ads)
generic
type Dato is private;
procedure Intercambia (A,B : in out Dato);
Cuerpo (fichero intercambia.adb)
procedure Intercambia (A,B : in out Dato) is
Temp : Dato:=A;
begin
A:=B;
B:=Temp;
end Intercambia;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Subprogramas genéricos (cont.)
8
UNIVERSIDAD
DE CANTABRIA
Instanciación:
with Intercambia;
procedure Prueba is
procedure Intercambia_Enteros is new Intercambia(Integer);
A : Integer:=...;
B : Integer:=...;
begin
...
Intercambia_Enteros(A,B);
end Prueba;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
9
5.4. Tipos como Parámetros Genéricos
UNIVERSIDAD
DE CANTABRIA
Tipos discretos (enteros, enumerados, o caracteres):
- type T is (<>);
Tipos enteros:
- type T is range <>;
Tipos reales:
- type T is digits <>;
Cualquier tipo:
- type T is private;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: conjuntos genéricos de
elementos discretos
10
UNIVERSIDAD
DE CANTABRIA
generic
type Elemento is (<>);
package Conjuntos_Discretos is
type Conjunto is private;
function Vacio return Conjunto;
procedure Inserta (E : Elemento; C : in out Conjunto);
procedure Extrae (E : Elemento; C : in out Conjunto);
-- pertenencia
function "<" (E: Elemento; C: Conjunto) return Boolean;
function "+" (X,Y : Conjunto) return Conjunto; -- Unión
function "*" (X,Y : Conjunto) return Conjunto; -- Intersección
function "-" (X,Y : Conjunto) return Conjunto; -- Diferencia
function "<" (X,Y : Conjunto) return Boolean; -- Inclusión
No_Cabe : exception;
private
type Conjunto is array (Elemento) of Boolean;
end Conjuntos_Discretos;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo (cont.)
11
UNIVERSIDAD
DE CANTABRIA
Ejemplo de instanciación:
type Color is (Rojo, Verde, Amarillo, Azul);
package Colores is new Conjuntos_Discretos(Color);
use Colores;
Comentarios
• Si el tipo Elemento no fuese discreto no se podría usar como
índice de un array
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
12
5.5. Subprogramas como
Parámetros Genéricos
UNIVERSIDAD
DE CANTABRIA
Se puede incluir un subprograma como parámetro genérico
formal:
with procedure P (lista parámetros);
with function F (lista parámetros) return tipo;
Al instanciar la unidad genérica se debe incluir un parámetro
actual que sea un procedimiento con el mismo perfil (mismos
parámetros).
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo
13
UNIVERSIDAD
DE CANTABRIA
Ejemplo de una función que permite calcular la integral de
cualquier función real
Especificación
generic
Num_intervalos : Positive;
with function F(X : Float) return Float;
function Integral (A,B : Float) return Float;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo (cont.)
14
UNIVERSIDAD
DE CANTABRIA
Cuerpo
function Integral (A,B : Float) return Float is
Delta_X
: Float :=(B-A)/Float(Num_Intervalos);
X
: Float :=A+Delta_X/2.0;
Resultado : Float :=0.0;
begin
for i in 1..Num_Intervalos loop
Resultado:=Resultado+F(X)*Delta_X;
X := X+Delta_X;
end loop;
return Resultado;
end Integral;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
15
Ejemplo de Uso de Función Genérica
UNIVERSIDAD
DE CANTABRIA
Ejemplo del cálculo de la integral de x2 entre 0.5 y 1.5:
with Integral, Ada.Text_IO, Ada.Float_Text_IO;
use Ada.Text_IO, Ada.Float_Text_IO;
procedure Prueba_Integral is
function Cuadrado (X : FLOAT) return Float is
begin
return X*X;
end Cuadrado;
function Integral_Cuad is new Integral(1000,Cuadrado);
begin
Put("Integral de x**2 entre 0.5 y 1.5: ");
Put(Integral_Cuad(0.5,1.5));
New_Line;
end Prueba_Integral;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Otro ejemplo de instanciación
16
UNIVERSIDAD
DE CANTABRIA
Ejemplo del cálculo de la integral de log(x) entre 2.1 y 3.2:
with Integral, Ada.Text_IO, Ada.Float_Text_IO,
Ada.Numerics.Elementary_Functions;
use Ada.Text_IO, Ada.Float_Text_IO,
Ada.Numerics.Elementary_Functions;
procedure Prueba_Integral is
function Integral_Log
is new Integral(1000,Log);
begin
Put("Integral de log(x) entre 2.1 y 3.2: ");
Put(Integral_Log(2.1,3.2));
Text_IO.New_Line;
end Prueba_Integral;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
5.6. Punteros a subprogramas
17
UNIVERSIDAD
DE CANTABRIA
En Ada 95 se prefiere para un caso como el de la función integral
el uso de punteros a subprogramas
La definición de un tipo puntero a subprograma es:
type nombre is access function (parámetros) return tipo;
type nombre is access procedure (parámetros);
Permite reemplazar en algunos casos a los subprogramas usados
como parámetros genéricos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
18
Ejemplo: Integral con punteros
UNIVERSIDAD
DE CANTABRIA
type P_Func is access function (X : Float) return Float;
function Integral
(F : P_Func; A,B : Float;
Num_Intervalos : Positive:=1000)
return Float
is
Delta_X : float := (B-A)/Float(Num_Intervalos);
X : Float := A+Delta_X/2.0;
Resultado : Float := 0.0;
begin
for i in 1..Num_Intervalos loop
Resultado:=Resultado+F(X)*Delta_X;
X:=X+delta_X;
end loop;
return Resultado;
end Integral;
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
Ejemplo: Integral con punteros (cont.)
19
UNIVERSIDAD
DE CANTABRIA
Ejemplo de cálculo de la integral de x2 entre 0.5 y 1.5:
function Cuadrado (X : Float) return Float is
begin
return X*X;
end Cuadrado;
procedure Prueba_Integral is
begin
Put("La Integral de x**2 entre 0.5 y 1.15:");
Put(Integral(Cuadrado’Access,0.5,1.5));
New_Line;
end Prueba_Integral;
Sin embargo, en otros casos el uso de subprogramas como
parámetros genéricos es adecuado
• p.e., si la unidad ya tiene otros parámetros genéricos
GRUPO DE COMPUTADORES Y TIEMPO REAL
FACULTAD DE CIENCIAS
© J. Javier Gutiérrez, Michael González Harbour
19/nov/10
20