Transparencias Seminario de Ada

Una Introducción a
Ada
Una Introducción a Ada
Contenido
1.  Introducción. Visión de conjunto
2.  Cuestiones léxicas
3.  Tipos de datos
4.  Expresiones
5.  Estructuras de control
6.  Subprogramas: Funciones y procedimientos
7.  Paquetes
8.  Excepciones
Introducción a Ada - 2
Visión de Conjunto
Ada es un lenguaje estilo Pascal / C
¿Qué es un programa Ada?
Es un Programa Principal (Unidad de Biblioteca)
que hace uso de los servicios de otras
unidades de biblioteca
Programa Principal
A
B
Subprogramas
C
D
Paquetes
Procedimientos
o Funciones
Abstracciones
E
Introducción a Ada - 3
Creación de programas Ada
Fichero con
código Ada
de E
Compilador
Ada
Fichero con
código Ada
de C
Compilador
Ada
·
·
·
Fichero con
código Ada
de PP
Compilador
Ada
E
E
C
A
B
D
C
E
PP
Programa Principal
A
B
D
C
E
Montador
(linker)
Ejecutable
PP
Introducción a Ada - 4
Un programa sencillo
Vamos a escribir un programa que calcule la raíz cuadrada
de 2,5 y la visualice por el dispositivo estándar de
entrada/salida.
Suponemos que en la biblioteca de programas disponemos,
al menos, de estas unidades:
Sqrt:
Función que devuelve la raíz
cuadrada del número que se le pasa
como parámetro.
ES_sencilla: Paquete que suministra un conjunto de
procedimientos para lectura/escritura
de números, caracteres, etc.
Introducción a Ada - 5
Un programa sencillo
with Sqrt, ES_sencilla;
use ES_sencilla;
-- Clausulas
-- de dependencia
procedure Imprimir_raiz is --begin
-PUT(Sqrt((2.5));
-end Imprimir_raiz;
Parte
declarativa
Parte
ejecutable
• No se distinguen mayúsculas y minúsculas.
• Se suelen utilizar minúsculas para palabras reservadas
• El “;” es el terminador de sentencia
• Los comentarios -- finalizan con la línea
• Con with se indican las unidades de biblioteca necesitadas.
• Con use se hacen directamente visibles los servicios
exportados por un paquete. Evita: ES_sencilla.PUT(…);
Introducción a Ada - 6
Ampliando el programa
Podemos mejorar el programa,
para que pregunte por el número
del que se desea obtener la raíz cuadrada.
with Sqrt, ES_sencilla;
use ES_sencilla;
procedure Imprimir_raiz is
x:FLOAT; -- Declaración de una variable x
-- de tipo FLOAT
begin
GET(X);
PUT(Sqrt(x));
end Imprimir_raiz;
Introducción a Ada - 7
Más difícil todavía
with Sqrt, ES_sencilla;
use ES_sencilla;
Pregunta hasta que el
procedure Imprimir_raiz is
valor indicado sea cero.
x:FLOAT;
begin
PUT("Raices cuadradas");
diferencias
NEW_LINE(2);
mayúsculas/minúsculas
loop
GET(x);
exit when x=0.0 –- salida del bucle
PUT("La raíz de ");
sobrecarga
PUT(x);
parámetros
PUT("es ");
opcionales
if x<0.0 then
con valor
PUT("No calculable");
por defecto
else
end if
PUT(Sqrt(x));
end loop
end if;
end Imprimir_raiz
NEW_LINE;
end loop;
NEW_LINE;
PUT("Fin del programa.");
end Imprimir_raiz;
Introducción a Ada - 8
Una función sencilla: Sqrt
function Sqrt(F:FLOAT) return FLOAT is
r:FLOAT;
-- variable local
-- Resto de objetos locales
-- necesarios para el cálculo
begin
-- Algoritmo de calculo de la
-- raiz cuadrada de F
return r;
end Sqrt;
Introducción a Ada - 9
Un paquete sencillo: ES_sencilla
ESPECIFICACIÓN de
ES_sencilla
package ES_sencilla is
procedure Get(F: out FLOAT);
procedure Put(F: in FLOAT);
procedure Put(F: in STRING);
procedure New_Line(N: in INTEGER := 1);
end ES_sencilla;
CUERPO (implementación) de
ES_sencilla
with Entrada_Salida;
package body ES_sencilla is
...
procedure Get(F: out FLOAT) is
...
-- Parte declarativa
begin
...
-- Sentencias
...
-- Sentencias
end Get;
...
end ES_sencilla;
Introducción a Ada - 10
Una Introducción a Ada
2. Cuestiones Léxicas
Introducción a Ada - 11
Cuestiones lexicográficas
CONJUNTO DE CARACTERES UTILIZADOS EN ADA
Letras
Cifras
Símbolos
A..Z
0..9
"#&'()*+,-./:;<=>_|
ALGUNOS DELIMITADORES COMPUESTOS
=>
..
**
:=
/=
>=
<=
Agregados, case, etc.
Rangos
Exponenciación
Asignación
Desigualdad
Mayor o igual
Menor o igual
Introducción a Ada - 12
Cuestiones lexicográficas
IDENTIFICADORES
son nombres de tipos, subtipos, variables, procedimientos,
funciones, paquetes, excepciones, …
IDENTIFICADOR ::= LETRA {[_] LETRA_O_CIFRA}
LETRA_O_CIFRA ::= LETRA | CIFRA
LETRA ::=
MAYÚSCULA | MINÚSCULA
Introducción a Ada - 13
Constantes númericas
Un poco sobre los números
ENTEROS: 150
15_273_542
REALES:
3.14159_26536 98.3E-2
80.0
7E2
¿Base distinta de 10?
2#01010011#
16#48AB6C#
8#71235471#E-2
base
número
exponente
Introducción a Ada - 14
Palabras reservadas
! Son identificadores que solamente
pueden utilizarse en ciertos contextos
definidos por el lenguaje
! No pueden utilizarse para definir
identificadores del usuario
! Pueden uilizarse en las tiras de
caracteres (strings).
Introducción a Ada - 15
Palabras reservadas
abort
abs
abstract
accept
access
aliased
all
and
array
at
begin
body
case
constant
declare
delay
delta
digits
do
else
elsif
end
entry
exception
exit
for
function
generic
goto
if
in
is
limited
loop
mod
new
not
null
of
or
others
out
package
pragma
private
procedure
protected
tagged
task
terminate
then
type
raise
range
rem
renames
requeue
return
reverse
until
use
when
while
with
xor
select
separate
subtype
Introducción a Ada - 16
Una Introducción a Ada
3. Tipos de Datos
Introducción a Ada - 17
Una Introducción a Ada
Tipos
TIPOS
Conjunto de valores al que se le pueden
aplicar unas determinadas operaciones
TIPO
Valores
Operaciones
Introducción a Ada - 18
Tipos
TYPE <Identificador> IS <Definicion_de_tipo>
type Ciudades is (Madrid, Toledo, Cuenca);
type Capitales is (Madrid, Roma, Paris);
Villa:
Ciudades;
Villa_europea: Capitales;
Villa := Madrid;
Villa_europea := Madrid;
Villa := Villa_europea;
¡Son tipos
diferentes!
Introducción a Ada - 19
Subtipos
SUBTIPOS
Subconjunto
TIPO de valores de un tipo,
pero manteniéndose todas las
SUBTIPO
operaciones
aplicables al tipo
TIPO
Valores
SUBTIPO
Operaciones
Introducción a Ada - 20
Subtipos
subtype Dia_del_mes is Integer range 1..31;
type Capitales is (Madrid, Roma, Paris);
subtype Capitales_extranjeras is
Capitales range Roma..Paris;
Un subtipo
NO introduce
un tipo nuevo
Dia : Dia_del_mes;
N
: Integer;
Dia := N;
Se pueden definir nuevos subtipos
a partir de otros subtipos
Introducción a Ada - 21
Tipos
Discreto
ESCALAR
Real
Entero (INTEGER)
Enumeración
Coma flotante
Coma fija
TIPOS
ESTRUCTURADO
Matriz
Registro
ACCESO (ACCESS)
PRIVADO (PRIVATE)
TAREA (TASK)
Introducción a Ada - 22
Tipos Enumerados
TYPE <identificador> IS (literal_o_carácter {,literal_o_carácter});
type Color is (Rojo, Ambar, Verde);
type Gema is (Ambar, Berilo, Cuarzo);
Hay "sobrecarga" en
SOLUCIONES:
- Por contexto
Ambar
Una_gema: Gema;
…
Una_gema := Ambar
- Por cualificación
Color'(Ambar)
ó Gema'(Ambar)
Pueden declararse subtipos a partir de estos tipos
subtype Cuidado is Color range Rojo..Ambar;
subtype Seguro is Color range Verde..Verde;
Introducción a Ada - 23
Tipos Enumerados
Tipos Enumerados Predefinidos
type BOOLEAN is (False, True);
type CHARACTER is (nul,… 'A','B','C',
…'a','b','c',…,del);
Introducción a Ada - 24
Tipos Numéricos
I, J : INTEGER;
F
: FLOAT;
El rango de los enteros viene limitado por la implementación
Subtipos Predefinidos
subtype NATURAL
is INTEGER range 0..INTEGER'Last;
subtype POSITIVE is INTEGER range 1..INTEGER'Last;
SHORT_INTEGER
LONG_INTEGER
Los puede ofrecer
la implementación
-- Se pueden convertir
I: integer;
F: float;
...
I:= integer(F) + 1;
F:= F + float(I);
Introducción a Ada - 25
Matrices
TYPE <identificador> IS ARRAY (rango_del_array) OF <tipo_de_los_elementos>
type Matriz is array (1..N, 1..M) of REAL;
type Semaforos is array (Color) of BOOLEAN;
type Vector is array (POSITIVE range <>) of REAL;
Asignación de Valores
Semaforo : Semaforos;
...
Semaforo(Rojo) := True;
Semaforo := (Rojo=>True, others=>False);
-------------------------------------Un_vector : Vector(1..20);
Otro_vector: Vector(5..50);
...
Un_vector(2) := 7.0;
Otro_vector(7..9) := (1.1, 2.2, 3.3);
Un_vector(1..10) := Otro_vector(11..20);
Introducción a Ada - 26
Agregados
Para dar valores a todos los elementos de un vector,
clásicamente se hace así:
Semaforo (Rojo) := True;
Semaforo (Ambar) := False;
Semaforo (Verde) := False;
Ahora es más fácil así:
Semaforo := (True, False, False);
Semaforo := (Rojo => True,
Ambar => False,
Verde => False);
Semaforo := (Rojo => True,
others => False);
Introducción a Ada - 27
Agregados
¿Cómo inicializamos un vector?
type Lineas is array (1..80) of Character;
...
Linea : Lineas := (' ',' ',' ',' ',...,' ');
Es más fácil así:
Linea : Lineas := (others => ' ');
Esta última forma siempre será válida,
aunque en un futuro cambiemos
el rango del vector.
Introducción a Ada - 28
Tiras de Caracteres (Strings)
type String is
array (Positive range <>) of Character;
S
: String (1..20);
Estrellas: String (1..120) := (others => '*');
Str1: String(1..8) := "Un Valor";
Str2: String(3..10);
Str3: String(1..10);
...
¡ERROR!
...
solo se pueden asignar strings
Str2 := Str1;
de la misma longitud
Str3 := Str1;
...
Str3(1..8) := Str2;
Introducción a Ada - 29
Tiras de Caracteres (Strings)
Operador & (concatenador de matrices)
Escribir nombre y apellidos
...
Put(Nombre);
Put(" ");
Put(Apellidos);
...
...
Put(Nombre & " "
& Apellidos);
¡ Más
Fácil !
Introducción a Ada - 30
Registros
type <identificador> is
record
<identificador>
{,<identificador>}:<tipo_del_campo> [:= <expresión>]
...
end record;
Introducción a Ada - 31
Registros
type Nombres is array (1..50) of Character;
type Fechas is
record
Dia : Integer range 1..31;
Mes : Integer range 1..12;
Anyo : Integer;
end record;
type Fichas is
record
Nombre
: Nombres;
Fecha_Nacimiento : Fechas;
end record;
Ficha : Fichas;
Ficha.Nombre := (others > ' ');
Ficha.Fecha_nacimiento.Dia := 15;
Ficha.Fecha_nacimiento.Mes := 9;
Ficha.Fecha_nacimiento.Anyo:= 1956;
Ficha.Fecha_nacimiento := (15,9,1956);
Introducción a Ada - 32
Tipo ACCESO
type <identificador> is access <nombre_tipo>
Según el ejemplo anterior de la fichas,
nos podría interesar disponer
de un fichero encadenado.
Primera: Dir_123
Nombre: …
Fecha_nacimiento: …
Siguiente: …
Nombre: …
Fecha_nacimiento: …
Siguiente: …
Nombre: …
Fecha_nacimiento: …
Siguiente: null
"ACCESOS"
Fin de
la lista
Introducción a Ada - 33
Tipo ACCESO
type Fichas; -- Para deshacer el ciclo
type Puntero is access Fichas;
type Fichas is
record
Nombre:
Nombres;
Fecha_nacimiento: Fechas;
Siguiente:
Puntero;
end record;
Introducción a Ada - 34
Tipo ACCESO
Primera: Puntero;
...
Primera := new Fichas;
Primera.Fecha_nacimiento := (15,9,1956);
Primera.Siguiente := new Fichas;
Primera: Dir_xxx
Nombre: …
Fecha_nacimiento: 15-9-1956
Siguiente: Dir_xxx
Nombre: …
Fecha_nacimiento: …
Siguiente: null
Introducción a Ada - 35
Conversión de Tipos
I : Integer := 3;
R : Real
:= 5.6;
...
...
I + R
¡ ERROR !
Real(I) + R
8.6
I + Integer(R)
9
utiliza REDONDEO
no truncamiento
Para poder aplicar la conversión,
tiene que existir cierto grado de compatibilidad
entre los tipos.
Introducción a Ada - 36
Algunas conversiones permitidas
Los arrays deben ser de la misma longitud
en todas sus dimensiones, y los tipos de los índices
y de los componentes deben ser compatibles.
type Vectores_A is array(1..5) of Real;
type Vectores_B is array(1..5) of Real;
...
Vector_A: Vectores_A;
Vector_B: Vectores_B; -- tipo distinto!
Un_vector: array(1..5) of Real; -- !ANONIMO!
...
Vector_A := Vectores_A(Vector_B);
Vector_A(1..3) := Vectores_A(Vector_B)(2..4);
Un_vector := Vector_B; -- !!! ERROR !!!
¡ HUIR DE LOS TIPOS ANÓNIMOS !
Introducción a Ada - 37
Algunas conversiones permitidas
En los tipos enumerados, la conversión se realiza
tomando como valor la posición ordinal que ocupa
cada elemento en la definición de su tipo.
type Romanos is (I,V,X,L,C,D,M);
type Arábigos is (Uno,Cinco,Diez,Cincuenta,
Cien,Quinientos,Mil);
...
A: Arabigos;
...
A:= Arabigos(X); -- A toma el valor "Diez"
Introducción a Ada - 38
Una Introducción a Ada
4. Expresiones
Introducción a Ada - 39
Expresiones
Lógicos (and, or, xor, not)
A and (B or C)
V := B=C
Operadores
A := B+C;
if x>Y then ...
Aritméticos (+,-,*,/,MOD,REM,**,ABS)
3+2
5
7/3
2
Relacionales
3**2
9
(=,/=,<,>,<=,>=)
ABS(3)
3
A < B
ABS(-3)
3
A /= B
A >= B
(A > B) and (C < D)
Concatenación (&)
"ARCO" & " " & "IRIS"
"ARCO IRIS"
Introducción a Ada - 40
Atributos
Expresiones
ATRIBUTOS
Son funciones que aplicadas a Tipos y Objetos,
devuelven ciertas características suyas.
ADDRESS
procedure Proc (V: System.Address) is
begin
...
end Proc:
V1: Mi_tipo;
...
Proc (V1'Address);
Introducción a Ada - 41
Atributos
Expresiones
type Color is (Rojo, Ambar, Verde);
PRED
Color'Pred(Verde)
Ambar
Color'Pred(Rojo)
¡Error!
SUCC
Color'Succ(Verde)
¡Error!
Color'Succ(Rojo)
Ambar
Color'Succ(Color'Pred (Ambar))
Ambar
Introducción a Ada - 42
Atributos
Expresiones
FIRST
type Color is (Rojo, Ambar, Verde);
type Semaforo is array (Color) of Boolean;
...
Mi_semaforo: Semaforo := (True,False,False);
Color'First
Semaforo'First
Mi_Semaforo'First
Rojo
Rojo
Rojo
LAST
Color'Last
Verde
Semaforo'Last
Mi_Semaforo'Last
Verde
Verde
False
Mi_Semaforo(Mi_Semaforo'Last)
Introducción a Ada - 43
Atributos
Expresiones
RANGE
P'Range
P'First..P'Last
for I in Rojo..Verde loop
Mi_semaforo(I) := false;
...
end loop;
equivalente
for I in Mi_semaforo'Range loop
Mi_semaforo(I) := false;
...
end loop;
LENGTH
Mi_Semaforo'Length
3
Introducción a Ada - 44
Una Introducción a Ada
5. Estructuras de Control
Introducción a Ada - 45
Estructuras de Control
IF
...
...
END IF;
CASE
...
...
END CASE;
LOOP
...
...
END LOOP;
WHILE …
FOR …
Introducción a Ada - 46
Bifurcación Condicional
Sentencia IF
IF <condición> THEN
<secuencia_de_instrucciones>
{ELSIF <condición> THEN
<secuencia_de_instrucciones>
[ELSE
<secuencia_de_instrucciones>
END IF;
if Hay_comida then
Comer;
else
Pasar_hambre;
end if;
if Dinero > 0 then
Me_compro_algo;
elsif Dinero = 0 then
Salgo_de_paseo;
else
Me_escondo_de_los_acreedores;
end if;
Introducción a Ada - 47
Bifurcación Condicional
Un caso peligroso
if X/Y < 0 then
Hacer_algo;
end if;
SI Y=0
¡ERROR!
S O L UC I O N E S
if Y/= 0 then
if X/Y < 0 then
Hacer_algo;
end if;
end if;
if Y/= 0 and then X/Y< 0 then
Hacer_algo;
end if;
Introducción a Ada - 48
Bifurcación Condicional
Otro caso problemático
subtype Rango is integer range 1..10;
X: array (Rango) of integer;
I: integer;
...
...
if not (I in Rango) or X(I) < 0 then
Mensaje de error;
si esto se evalúa primero
y además I=15
end if;
LA SOLUCIÓN
¡ERROR!
...
if not (I in Rango) or else X(I) < 0 then
Mensaje_de_Error;
end if;
Introducción a Ada - 49
Sentencia CASE
Sentencia CASE
CASE <expresión> IS
WHEN <opciones> => <Secuencia_de_instrucciones>;
{WHEN <opciones> => <Secuencia_de_instrucciones>;
END CASE;
type Meses is (Ene,
Jul,
Mes: Meses;
...
case Mes is
when Oct
when Jul..Ago
when Feb|Jun|Jul
when others
Feb, Mar, Abr, May, Jun,
Ago, Sep, Oct, Nov, Dic);
=>
=>
=>
=>
Vuelta_a_clase;
Las cláusulas when
null;
cubrir todos
Examinarse; deben
los valores del
Estudiar;
discriminante.
Ir_de_copas;
end case;
Introducción a Ada - 50
Sentencias de Bucles
Sentencia LOOP
LOOP
<Secuencia_de_Sentencias>
END LOOP;
Instrucción de Salida del Bucle
EXIT
así, más claro
loop
loop
...
...
...
...
if Mi_condicion then exit when Mi_condicion;
exit;
...
end if;
...
end loop;
end loop;
Introducción a Ada - 51
Bucle WHILE
Bucle WHILE
WHILE <condición> LOOP
<Secuencia_de_Sentencias>
END LOOP;
...
...
while not arreglado loop
...
Arreglar(El_mundo, arreglado);
...
exit when Otra_condicion;
...
end loop;
...
Introducción a Ada - 52
Bucle FOR
Bucle FOR
FOR <variable> IN [reverse] <rango> LOOP
<Secuencia_de_Sentencias>
END LOOP;
variable declarada implícitamente aquí
...
for I in 1..100 loop
...
Se puede salir
Estudiar(Algoritmica, aprendido);
por otra condición
exit when aprendido;
La variable de
control se puede leer
...
Contador := I;
I:= Contador;
...
La variable de
control
NO se puede
end loop;
modificar
...
Introducción a Ada - 53
Bucles anidados
loop
...
...
while Una_condicion loop
...
exit when Otra_condicion;
...
end loop;
...
for I in lunes..viernes loop
trabajar;
end loop;
...
end loop;
Introducción a Ada - 54
Una Introducción a Ada
6. Subprogramas
(Funciones y Procedimientos)
Introducción a Ada - 55
Subprogramas (Funciones y Procedimientos)
FUNCIONES
FUNCTION <nombre_función> (p1: t1;
p2: t2;
...
pn: tn) RETURN t IS
<declaraciones_locales>
BEGIN
...
...
RETURN <expresión>;
...
END <nombre_función>;
Introducción a Ada - 56
Funciones
function Factorial (N: positive)
return positive is
begin
if N=1 then
return 1;
else
return N * Factorial(N-1);
end if;
end Factorial;
Algunas
Formas
de Llamada
F: positive;
...
F := Factorial(5);
...
for I in 1.10 loop
Put (Factorial(I));
New_Line;
end loop;
Introducción a Ada - 57
Procedimientos
PROCEDIMIENTOS
PROCEDURE <nombre_procedimiento> (p1: <modo> t1;
p2: <modo> t2;
...
pn : <modo> tn)
<declaraciones_locales>
BEGIN
<sentencias>
In
solo se pueden
...
leer
Modo
[RETURN];
Out
solo pueden
...
recibir valores
END <nombre_procedimiento>;
In Out se pueden leer
y recibir valores
Introducción a Ada - 58
Procedimientos
Procedimiento que calcula
H2 – C12
H
¿C2?
C1
procedure Cateto(H,C1: in
real;
C2:
out real;
Error: out boolean) is
Aux: constant real := H**2 – C1**2;
begin
Error := Aux < 0.0;
Ejemplo de llamada
if Error then
Hip:
real := 9.5;
return;
Cat_1: real := 7.0;
else
Cat_2: real;
C:= Sqrt(Aux);
Fallo: boolean;
end if;
...
end Cateto;
...
Cateto(Hip,Cat_1,Cat_2,Fallo);
...
Introducción a Ada - 59
Paso de Parámetros por Nombre
Al procedimiento Proc
procedure Proc (I: integer;
J: integer);
se le puede llamar así:
Proc (5, 8);
Proc (I => 5, J => 8);
Proc (J => 8, I => 5);
Proc (5, J => 8);
Introducción a Ada - 60
Parámetros por Defecto
Se pueden establecer valores por defecto
para los parámetros de entrada (tipo IN)
type Licores is (Ginebra, Vodka);
type Estilo is (Con_hielo, Seco);
type Extra
is (Aceituna, Limon);
...
procedure Martini is (Base: Licores := Ginebra;
Como: Estilo := Con_hielo;
Con: Extra
:= Limon);
Algunas
Llamadas
Martini (Como => Seco);
Martini (Vodka, Con => Aceituna);
Martini (Ginebra, Seco);
Martini;
Se pueden mezclar las notaciones Posicional y Por Nombre,
pero una vez que se empieza a nombrar, se deben nombrar hasta el final.
Introducción a Ada - 61
Sobrecarga de Subprogramas
type Raices is (Bulb, Rizoma, Otros);
type Plantas is (Margaritas, Jacintos, Lirios);
---------------------------------------------function Raiz (Mi_planta: Plantas)
return Raices is
begin
... -- Devuelve el tipo de raiz
... -- de la planta.
end Raiz;
---------------------------------------------function Raiz (V: integer) return real is
begin
... -- Calcula la raiz cuadrada
... -- de un numero entero.
end Raiz;
---------------------------------------------function Raiz (V: real) return real is
begin
... -- Calcula la raiz cuadrada
... -- de un numero real.
end Raiz;
¡3 funciones
con el mismo
nombre!
Introducción a Ada - 62
Sobrecarga de Subprogramas
Algunas Llamadas
x:= Raiz(Lirios);
Y:= Raiz(8);
Z:= Raiz(8.0);
La ambigüedad se resuelve por
el tipo de los parámetros
y el tipo del valor que devuelve la función.
¿Y si también hay ambigüedad
en los parámetros?
Hay que cualificarlos
Raices'(Bulbo)
Introducción a Ada - 63
Sobrecarga de Operadores
Se pueden definir funciones cuyo identificador
sea alguno de los operadores predefinidos
+ - * < > . . . = /=
function Suma_matrices (M1, M2: Matrices)
return Matrices is
...
end Suma_matrices;
...
A, B, C: Matrices;
...
A := Suma_matrices (B,C);
¡Mejor así!
No se permiten valores por defecto
para los parámetros.
Se debe mantener el número original de
parámetros de los operadores
predefinidos (unarios o binarios).
function "+" (M1, M2: Matrices)
return Matrices is
...
end "+";
...
A, B, C: Matrices;
...
A := B+C;
-- Uso infijo
A := "+"(B,C); -- Uso prefijo ¡¡??
Introducción a Ada - 64
Una Introducción a Ada
7. Paquetes
Introducción a Ada - 65
Paquetes
Vamos a implementar una pila de enteros …
Max : constant := 100;
Pila: array (1..Max) of integer;
Cima: integer range 0..Max := 0;
procedure Meter(X: integer) is
begin
Cima := Cima + 1;
Pila(Cima) := X;
end Meter;
procedure Sacar(X: out integer) is
begin
X := Pila(Cima);
Cima := Cima - 1;
end Sacar;
¡Problema!
El usuario tiene acceso
a las variables Pila y Cima,
por lo que podría realizar
manipulaciones incorrectas
no deseadas.
Introducción a Ada - 66
Paquetes
Los paquetes son módulos
que encapsulan un conjunto
de recursos relacionados
(todo lo que se puede declarar en Ada)
Constan de
Especificación
(parte accesible)
Implementación
o cuerpo
(parte inaccesible)
Especificación (parte accesible)
package Pila_enteros is
procedure Meter(X: integer);
procedure Sacar(X: out integer);
end Pila_enteros;
Introducción a Ada - 67
Paquetes
Implementación o cuerpo (parte inaccesible)
package body Pila_enteros is
Max: constant := 100;
Pila: array (1..Max) of integer;
Cima: integer range 0..Max;
procedure Meter(X: integer);
begin
Cima := Cima + 1;
Pila(Cima) := X;
end Meter;
procedure Sacar(X: out integer);
begin
X := Pila(Cima);
Cima := Cima - 1;
end Meter;
begin -- Inicialización del paquete (opcional)
Cima := 0;
end Pila_enteros;
Introducción a Ada - 68
Cláusula WITH
Paquetes
¿Cómo indica el usuario
los paquetes que necesita?
Con la cláusula WITH
with Pila_enteros;
procedure Ejemplo_1 is
I: integer;
begin
...
Pila_enteros.Meter(I);
...
Pila_enteros.Sacar(I);
...
end Ejemplo_1;
Introducción a Ada - 69
Cláusula USE
Paquetes
¿Y para hacer directamente visibles
los servicios del paquete?
Con la cláusula USE
with Pila_enteros;
use Pila_enteros;
procedure Ejemplo_1 is
I: integer;
begin
...
Meter(I);
...
Sacar(I);
end Ejemplo_1;
Introducción a Ada - 70
Texto
Algunos paquetes útiles para E/S
package Text_IO is
procedure New_Line(Spacing: positive := 1);
procedure Get(Item: out character);
procedure Put(Item: in character);
procedure Get(Item: out string);
procedure Put(Item: in string);
procedure Get_line(Item: out string;
Last: out natural);
procedure Put_line(Item: in string);
...
...
end Text_IO;
Introducción a Ada - 71
Algunos paquetes útiles para E/S
Texto
with Text_IO; use Text_IO;
procedure Adivina_nombre is
Nombre:
string (1..20);
Long_nombre: natural;
begin
Put("¿Cómo te llamas?: ");
Get_Line(Nombre, Long_nombre);
Put_Line("¡Ya sé cómo te llamas?");
Put("Te llamas ");
Put(Nombre(1..Long_nombre);
end Adivina_nombre;
Introducción a Ada - 72
Algunos paquetes útiles para E/S
Números Enteros
with Text_IO; use Text_IO;
procedure Adivina_numero is
type Mis_numeros is new integer range -20..20;
package Mis_numeros_IO is new integer_IO(Mis_numeros);
use Mis_numeros_IO;
Numero: Mis_numeros;
begin
Put("Piensa y escribe un número del -10 al 10: ");
Get(Numero);
New_line;
Put("El doble del número pensado es el ");
Put(Numero*2); -- ¡Se puede operar con Numero!
end Adivina_numero;
Introducción a Ada - 73
Algunos paquetes útiles para E/S
Ficheros y Números Enteros
with Sequential_IO, Text_IO;
procedure prueba_fiheros is
package Ficheros_enteros is new Sequential_IO(integer);
use Ficheros_enteros;
package Enteros_IO is new Text_IO.Integer_IO(integer);
use Enteros_IO;
fichero: file_type;
valor:
integer := 7;
begin
create(fichero, out_file, "Fichero_prueba");
write(fichero, valor*2);
close(fichero);
open(fichero, in_file, "Fichero_prueba");
read(fichero, valor);
close(fichero);
put(valor);
end prueba_ficheros;
Introducción a Ada - 74
Unidades de Biblioteca Predefinidas
Paquete CALENDAR
Paquete SYSTEM
Paquete MACHINE_CODE (opcional)
Procedimiento genérico UNCHECKED_DEALLOCATION
Función genérica UNCHECKED_CONVERSION
Paquete genérico SEQUENTIAL_IO
Paquete genérico DIRECT_IO
Paquete TEXT_IO
Paquete IO_EXCEPTIONS
Paquete LOW LEVEL_IO
Introducción a Ada - 75
Paquete SYSTEM
En la programación, hay algunos elementos cuyo manejo resulta peligroso…
pero que, a veces, son imprescindibles.
package System is
type Address is definido_en_implementación
type Name
is definido_en_implementación
System_Name
: constant Name := def_impl.
Storage_Unit : constant := def_impl.
Memory_Size : constant := def_impl.
-- Números con
Min_Int
:
Max_Int
:
Max_Digits
:
Max_Mantissa :
Fine_Delta
:
Tick
:
...
end System;
nombre dependientes del sistema.
constant := def_impl.
constant := def_impl.
constant := def_impl.
constant := def_impl.
constant := def_impl.
constant := def_impl.
Introducción a Ada - 76
Una Introducción a Ada
8. Excepciones
Introducción a Ada - 77
Excepciones
Una Excepción se produce ante:
• Una situación excepcional: Ej. Fin de Fichero (alto nivel)
• Un error: Ej. Error de Lectura en Disco
(bajo nivel)
Introducción a Ada - 78
Excepciones
procedure Facturacion is
...
Fin_fichero: boolean := FALSE;
o
t
...
mien l
a
t
a
a
n
Tr
begin
encio
v
n
o
C
while not Fin_fichero loop
Leer_pedido(Pedido, Fin_fichero);
if not Fin_Fichero then
Tratar_pedido(Peido);
end if;
end loop;
...
end Facturación;
Introducción a Ada - 79
Excepciones
iento
m
a
t
Tra
nal
o
i
c
p
Exce
procedure Facturacion is
...
Fin_fichero: boolean;
...
begin
loop
Leer_pedido(Pedido, Fin_fichero);
Tratar_pedido(Pedido);
end loop;
...
exception
when End_error => -- Fin de fichero
Text_IO.Put_line("Se acabó");
end Facturación;
Introducción a Ada - 80
Cuestiones sobre las Excepciones
" ¿Cómo se declara una excepción?
¿Cómo se alcanza o señala una condición
# de excepción?
¿A dónde se cede el control una vez tratada
$ la excepción?
procedure Principal is
Excepcion_local: exception;
begin
...
if Condición_extraña then
raise Excepcion_local;
end if
...
exception
when Constraint_error => Hacer_algo;
when Excepcion_local => Hacer_otra_cosa;
when others
=> No_se_que_hacer;
end Principal;
Introducción a Ada - 81
Excepciones
Declaración y Tratamiento
procedure Principal is
procedure Calculo is
...
Excepcion_local: exception;
begin
...
raise Excepcion_local;
...
exception
when Excepcion_local =>
Put_line("¡Te pillé!");
end Calculo;
begin -- Principal
...
Calculo;
exception
when others =>
Put_line("Algo raro pasa!!!);
raise;
end Principal;
La declaración de una excepción es
similar a la de otros objetos, y
sigue las mismas reglas de ámbito,
aunque sus efectos pueden
propagarse más allá de su ámbito.
RAISE sin nombre de excepción
solamente puede utilizarse dentro
de un manejador de excepciones.
Su efecto es propagar al exterior
la excepción que se está tratando.
El manejador OTHERS sirve para
tratar excepciones que se han
propagado fuera de su ámbito
porno encontrar un manejador.
Introducción a Ada - 82
Señalamiento de Excepciones
Una excepción puede señalarse
Implícitamente
(comprobaciones en ejecución)
CONSTRAINT_ERROR
Access_Check
Discriminant_Check
Division_Check
Index_Check
Length_Check
Overflow_Check
Range_Check
Tag_Check
Explícitamente
(sentencia RAISE)
PROGRAM_ERROR
Elaboration_Check
Accessibility_Check
STORAGE_ERROR
Storage_Check
TASKING_ERROR
pragma Suppress (All_Checks);
Introducción a Ada - 83