Академический Документы
Профессиональный Документы
Культура Документы
Sintaxis de Programa
<Programa Principal>
<declaracion de constantes>
---------------------------------------------------------
-- Comienzo del Programa Principal
---------------------------------------------------------
begin
<sentencias ejecutables>
Ejemplo :
------------------------------------------------------------
--
-- Autor : Patricia
-- Descripcion : Este programa simplemente saluda al mundo diciendo: Hola Mundo!!!
¿Cómo está el día?
-- Algoritmo :
-- Imprime el mensaje en la pantalla
--
------------------------------------------------------------
with Ada.Text_IO;
use Ada.Text_IO;
procedure Primer_Mensaje is
------------------------------------------------------------
-- comienzo del programa principal
------------------------------------------------------------
begin
1
Sintaxis de Ada
Ejemplo :
------------------------------------------------------------
--
-- Autor : Patricia
-- Descripcion : este paquete contiene el encabezado de un procedimiento simple en
Ada denominado Primera_Presentacion.
--
------------------------------------------------------------
with Ada.Text_IO;
use Ada.Text_IO;
package Ejemplo2 is
procedure Primera_Presentacion;
end ejemplo2;
Ejemplo :
------------------------------------------------------------
--
-- Autor : Patricia
-- Descripcion : este paquete contiene el cuerpo del procedimiento en Ada
-- denominado Primera_Presentacion.
------------------------------------------------------------
2
Sintaxis de Ada
with Ada.Text_IO;
use Ada.Text_IO;
procedure Presentacion is
begin
put(item=>”Hola mundo, Este es mi primer package, aleluya!!!”) ;
end Presentacion;
end ejemplo2;
Al guardar estos archivos en ADA, se genera un .ads (con las especificaciones, encabezado), y el
segundo genera un .adb (el body o cuerpo). Para usarlos en otro programa, se los debe mencionar en la
with (contexto de uso), y se lo debe especificar en la cláusula use.
Ejemplo:
with ejemplo2;
use ejemplo2;
procedure ejemplo_macro is
begin
Presentacion;
end;
Variables
<nombre de variable> : <tipo de dato >;
Ejemplos :
Letra_Inicial : Character;
Apellido : String(1..15);
Longitud_nombre : Integer;
Radio : Float;
Pi : constant Float := 3.1416;
Sentencia de Asignación
<nombre de variable> := <expresion>;
<expresion> - alguna fórmula matemática
Ejemplo :
Area := Pi * Radio ** 2;
3
Sintaxis de Ada
Entrada Simple
Salida Simple
Integer
Put (Item => <nombre de variable>,
Width => <numero entero>);
Float
Put (Item => <nombre de variable>,
Fore => <numero entero>,
Aft => <numero entero>,
Exp => <numero entero>);
Ejemplo :
Entrada Simple
Get (Item => Longitud_nombre);
Get (Item => Radio);
Get (Item => Letra_inicial);
Get (Item => Apellido);
Salida Simple
Put (Item => Longitud_nombre,Width => 3);
Put (Item => Radio, Fore => 3, Aft => 2, Exp => 0);
Put (Item => Letra_inicial);
Put (Item => Apellido);
Put_Line (Item => Letra_inicial);
Put_Line (Item => Apellido);
4
Sintaxis de Ada
Ejemplo :
if ( Promedio >= 8.0 ) then
-- Imprimir mensaje para Dany
Put (Item => "Tiene muy buen promedio");
New_Line;
end if;
5
Sintaxis de Ada
Nota : La sentencia if de múltiples alternativas puede tener tantas elsif porciones como Ud necesite, y
la porción else en una sentencia if de múltiples alternativas es opcional.
Example :
Ejemplo :
if ( Promedio >= 8.0 ) then
-- Imprimir mensaje alentador
Put (Item => "Tiene muy buen promedio");
New_Line;
-- en otro caso
elsif (promedio >= 6) then
-- Imprimir mensaje para mejorar
Put (Item => "Debe mejorar su dedicación ");
Put (Item => "Suerte la próxima!!!");
New_Line;
-- de otro modo
else
-- Imprimir mensaje de despedida
Put (Item => "Tendrá que ponerse a practicar!!!!!");
New_Line;
end if;
Sentencia Case
end case;
6
Sintaxis de Ada
Ejemplo :
case Puntaje is
-- Cuando el puntaje esta entre 90 y 100 imprimir felicitaciones
when 90 .. 100 => Put_Line (Item => "FELICITACIONES!!!!, tiene el primer
puesto");
-- de otro modo
when others => Put_Line (Item => "Lo siento, esta en el último lugar");
end case;
Iteración
< variable de control de ciclo > - este es el nombre de la variable que contola el “loop” y se incrementa de a uno
a lo largo del ciclo.
<límite inferior> - Valor inicial de la variable de control.
<límite superior> - Valor final de la variable de control. El cuerpo del ciclo se ejecuta una o más veces hasta
que la variable de control toma el valor del límite superior . Entonces el “loop” termina.
<cuerpo del ciclo> - Código que es ejecutado cada vez a lo largo del ciclo.
Ejemplo :
7
Sintaxis de Ada
loop
end loop;
OR
loop
end loop;
<Expresión Boolean > - expresión cuyo valor es True o False. Ésta es evaluada cada vez. Si es true, sale del
loop, y si es Falseejecuta la segunda parte del cuerpo del loop. La expresión Boolean debe contener por lo
menos una variable.
< primera parte del cuerpo del loop > - Código que se ejecuta antes del testeo de la expresión booleana
< segunda parte del cuerpo del loop > - Código que se ejecuta cuando la expresión es verdadera, y antes de
la primera parte .
Ejemplo 1 :
-- Loop
loop
Ejemplo 2:
-- Loop
loop
end loop;
<Expresión Boolean > - esta es la misma expresión booleana que se usa en una sentencia IF , y que se evalúa
simplemente como True o False. La expresión booleana es evaluada cada vez que se ejecuta el cuerpo del
ciclo. Si es True, “entra” al ciclo y ejecuta el cuerpo del mismo. Si es falsa, sale del ciclo. La expresión
booleana debe contener por lo menos una variable.
<cuerpo del ciclo> -es el código que se ejecuta cada vez dentro del ciclo
Ejemplo :
end loop;
9
Sintaxis de Ada
Subprogramas
En Ada, los subprogramas se dividen en dos categorías: procedimientos y funciones.
Sintaxis de Procedimiento
Los parámetros que se le pueden pasar a un procedimiento pueden ser de tres modos diferentes:
- in: el parámetro formal es constante y toma el valor del parámetro actual asociado. (Paso de parámetro
por valor).
- in out: el parámetro formal es una variable y este modo habilita la captura y modificación del valor del
parámetro actual asociado. (Paso de parámetro por referencia).
- out: el parámetro formal es una variable y este modo habilita únicamente la modificación del valor del
parámetro actual asociado.
Ejemplo
procedure Una_Prueba (A, B: in Integer; C: out Integer) is
begin
C:= A + B;
end Una_Prueba;
Cuando se invoca al procedimiento con la sentencia Una_Prueba (5 + P, 48, Q); las expresiones 5 + P
y 48 toman valor, son asignadas a los parámetros formales A y B, y éstos se comportan como
constantes durante la ejecución de Una_Prueba. Recuerde que sólo se permiten expresiones en los
parámetros actuales cuando el correspondiente parámetro formal está en modo in.
A continuación, se asigna el valor A + B a la variable formal C. Obsérvese que al especificar C de
modo out , el valor del parámetro actual (Q) no se conoce dentro de Una_Prueba. En este caso, el
parámetro formal C es una nueva variable cuyo valor se asignará al parámetro actual (Q) cuando
finalice el procedimiento. Si se hubiera querido trabajar con el valor de Q dentro de Una_Prueba, se
debería haber empleado C: in out Integer.
Sintaxis de función
Al contrario que los procedimientos, a la función sólo se le pueden pasar parámetros de modo entrada (in) . No
se puede especificar otro modo pues el de entrada es por defecto y obligatorio.
10
Sintaxis de Ada
Ejemplo:
function Mínimo (A, B: Integer) return Integer is
begin
if A > B then return (B);
else return (A);
end if;
end Mínimo;
Los parámetros formales de una función se comportan como constantes locales cuyos valores son
proporcionados por los parámetros actuales correspondientes.
La sentencia return se utiliza para indicar el valor devuelto por la llamada a la función y para devolver
el control a la expresión que llamó a la función. La expresión de la sentencia return es de complejidad
arbitraria y debe ser del mismo tipo que se declara en el encabezado de la función.. El cuerpo de la
función puede contener varias sentencias return y la ejecución de cualquiera de ellas terminará la
función devolviendo el control a la sentencia que la había invocado. Si el flujo del programa sigue
varios caminos dentro de la función hay que asegurarse de que se termine siempre con una sentencia
return en cada uno de ellos. Así pues, el cuerpo de una función deberá tener al menos una sentencia
return obligatoriamente.
Toda llamada a una función produce una nueva copia de cualquier objeto declarado dentro de ella,
incluyendo los parámetros. Cuando la función finaliza, desaparecen sus objetos. Por tanto, es posible
utilizar llamadas recursivas a una misma función. Como ejemplo, se muestra una posible
implementación de la función factorial:
function Factorial (N: integer) return integer is
begin
if N in (0..1) then
return 1;
else
return (N * Factorial (N - 1));
end if;
end Factorial;
Se la puede invocar de las siguientes maneras distintas, debiendo cuidarse que se use un parámetro
actual para cada parámetro formal:
I := Sumatoria(4);
I contiene el valor 10
I := Sumatoria(4) * Sumatoria(8) + 5;
I contiene el valor 365
Put(Sumatoria(4));
Imprime un 10
11
Sintaxis de Ada
Arreglos en Ada
Definición de tipo arreglo y declaración de variable arreglo
< constante tamaño del arreglo> : constant Integer := <tamaño del arreglo>;
type < nombre_tipo > is array (1 .. < constante tamaño del arreglo >)
of <tipo_elementos>;
<nombre_variable> : <nombre_tipo>;
< constante tamaño del arreglo > - nombre de la constante que almacena el tamaño del arreglo
<tamaño del arreglo > - El tamaño actual del arreglo.
< nombre_tipo > - El nombre del nuevo tipo que se está definiendo.
< tipo_elementos > - El tipo de cada elemento del arreglo.
< nombre_variable > - El nombre de la variable declarada de nuestro tipo arreglo nombre_tipo.
Ejemplos
precipitacione
28.0 26.0 20.0 16.0 14.0 10.0 9.0 10.0 15.0 18.0 22.0 25.0
temperaturas
12
Sintaxis de Ada
4.0 4.0 4.0 2.0 1.5 2.0 1.0 2.0 1.0 2.0 1.0 1.0
notas
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
Finales_aprobadoos
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
Ejemplos
precipitaciones:= (1|3 => 10.0, others => 5.0);
10.0 5.0 10.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0
precipitacione
precipitaciones(2..4) := (10.0, 9.0, 8.0);
10.0 10.0 9.0 8.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0
precipitacione
13
Sintaxis de Ada
precipitaciones(12) := 5.5;
10.0 10.0 9.0 8.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.5
precipitacione
2) Entrada y salida
--Entrada --Salida
Get (<variable_tipo_arreglo>(<indice>)); Put (<variable_tipo_arreglo>(<indice>));
Ejemplos
Get (finales_aprobados(1,5));
For i in inferior..superior loop
Put (precipitaciones(i)); New_line;
End loop;
procedure Vectores is
Maximo: constant integer := 5;
type Vector is array (1 .. Maximo) of Float;
Serie: Vector := (others => 0.0); Media: Float := 0.0;
14
Sintaxis de ADA
prom := acum/Float(Maximo);
end Media_Elementos;
begin
Leo_vector(Serie);
Media_Elementos(Serie,Media);
Imprimo_resultados(Serie,Media);
end Vectores;
Cadenas (Strings)
En Ada los strings son un tipo especial de array (no restringido) que está implicitamente
definido en el paquete Standard.
Por ser no restringidos debemos definir variables de tipo String fijando los límites del array
explícitamente o implícitamente.
Declaración de variables
subtype <nombre del subtipo> is String (1 .. < constante positivo>);
<nombre de variable> : <nombre del subtipo>;
Ejemplos
subtype Nombre_Cliente is String (1 .. 15);--definimos un subtipo de
-- tipo String
Nombre : Nombre_Cliente := "Pepe García "; -- Inicialización
Direccion : String (1 .. 30);
Saludo: constant String := "Hola!"; --En la declaración de constantes
-- se puede omitir la restricción
15
Sintaxis de ADA
Uso:
Nombre (4) := 'a'; -- Ahora Nombre es Pepa García
Nombre (1 .. 4) := "Jose"; -- Ahora Nombre es Jose García
Direccion := "Av. Kennedy"; -- Error: no tiene 30 caracteres!!
Solución: Utilizando slices* (rebanada) puedo manejar la dimensión. Por ejemplo, un slice
de la cadena anterior puede ser:
Direccion (1 .. 11) := "Av. Kennedy";
*Slice: recurso que provee Ada para hacer referencia a una parte de un array
16
Sintaxis de ADA
---------------------------------------------------------------------
-------------- ejemplo de uso de cadenas en ADA ------------------
---------------------------------------------------------------------
with gnat.io;use gnat.IO;
procedure Uso_string is
begin
Get_Line (cad1, longitud); --entrada de una cadena por consola
put (cad1 (1.. longitud)); --salida de una cadena indicando su rango
put (cad1); -- muestra la cadena de 1.. 15;
new_line; -- si no fue inicializada, muestra basura.
----- uso de slice ----------
cad2(2..4) := ('a','b','c'); -- conjunto de caracteres
cad2(1):= 'x'; -- un caracter
cad2(5..7):= "hoy"; -- un string, debe coincidir con el slice
cad2(8..11):= cad1(1..4); -- asignacion de slices
cad2(12..15) := (others => '*'); -- rellena con el carácter ‘*’
cad1:= cad2; -- es posible si tienen la misma longitud
if cad1(1) = 'a' then put_line("primer caracter de cad1 es a"); end if;
if cad1(1..2) = "ab" then put("cad1 comienza con la cadena ab"); end if;
end Uso_string;
Los record son estructuras heterogéneas: agregados de elementos (campos) del mismo o
distintos tipos que se pueden acceder individualmente mediante su nombre. Un record se
define con la palabra "record", seguida de la declaración de los campos del record y "end
record".
Declaración de tipo registro
17
Sintaxis de ADA
Ejemplo:
type fecha is
record
dia:integer range 1..31;
mes:string (1..10);
anio:integer;
end record;
nacimiento: fecha;
fecha_fija: constant fecha:= (dia => 01, mes => "Enero", anio => 2000);
Se pueden especificar valores iniciales para los campos de un record en la propia definición
del tipo.
type fecha is
record
dia:integer range 1..31;
mes:string (1..10) := (others => ' ');
anio:integer:=2007;
end record;
Los registros pueden ser manipulados como objetos completos. Además, es posible asignar
valores a todos los componentes de un registro mediante un conjunto ordenado o
desordenado.
18
Sintaxis de ADA
2. agregado nominal: especificando los nombres de los campos junto con los
valores:
nacimiento := (anio => 1980, mes => "Junio", dia => 17);
Cuando se usa un agregado nominal los campos se pueden enumerar en cualquier orden,
pero siempre hay que enumerarlos a todos.
Registros discriminados
Es un tipo de dato para un uso muy restringido. Un registro discriminado tiene un
componente discriminante, del que dependen otros tipos. A esa componente se la conoce
como discriminante y tiene que ser de tipo discreto.
Ejemplo:
type TMatriz is array (Integer range <>, Integer range <>) of Float;
type TMatrizCuadrada (Orden: Positive) is
record
Matriz: TMatriz(1..Orden,1..Orden);
end record;
M: TMatrizCuadrada(3);
P, Q: TPolinomio;
El valor inicial de sus discriminantes sería cero (el valor por defecto de N). Así,
se podría cambiar el discriminante posteriormente.
19
Sintaxis de ADA
Se pueden definir tipos record que puedan tener campos diferentes en función del valor de un
discriminate discreto.
type <nombre del tipo> is (<valor 1> , <valor 2> , … , <valor N>);
type <nombre del tipo> (<nombre del discriminante> : <nombre del tipo>) is
record
end record;
Ejemplo:
Archivos de Entrada/Salida
Los archivos con los que se trabaje deben “abiertos”, y en esa instancia, debe especificarse el
nombre lógico, el modo y la identificación del archivo físico en el soporte magnético en el
que está almacenado.
o Mode es el modo de apertura (puede tomar los valores: "In_File", "Out_File",
"Append_File").
20
Sintaxis de ADA
<nombre de variable>- Nombre de una variable declarada como nuestro archivo variable.
Ejemplo :
Input_File : tipo_archivo;
Ejemplo :
Cerrando un archivo
Ejemplo :
Creando un archivo
21
Sintaxis de ADA
Ejemplo :
Create (File => archivo_salida,
Mode => Out_File,
Name => "c:\output.dat");
Entrada Simple
Salida Simple
Enteros
Put (File => <nombre de variable_archivo>,
Item => <nombre de variable>,
Width => <numero entero>);
Flotantes
Put (File => <nombre de variable_archivo>,
Item => <variable name>,
Fore => <numero entero>,
Aft => <numero entero>,
Exp => <numero entero>);
Caracteres y Strings
Put (File => <nombre de variable_archivo>,
Item => <nombre de variable>);
22
Sintaxis de ADA
Ejemplos :
Entrada Simple
Get (File => Input_File, Item => Name_Length);
Get (File => Input_File, Item => Radius);
Get (File => Input_File, Item => First_Initial);
Get (File => Input_File, Item => Last_Name);
Salida Simple
Put (File => Output_File,
Item => Name_Length,
Width => 3);
Put (File => Output_File,
Item => Radius,
Fore => 3,
Aft => 2,
Exp => 0);
Put (File => Output_File, Item => First_Initial);
Put (File => Output_File, Item => Last_Name);
Archivos secuenciales
Los elementos necesarios para manejar archivos secuenciales se encuentran en el paquete
"Sequential_IO".
with Ada.Sequential_IO;
Declaración
Para poder usar archivos secuenciales se deben definir previamente el tipo de sus
componentes
type TPersona is
record
Nombre : string(1..20);
DNI : string(1..10);
Edad : natural;
end record;
Una vez definido el tipo, se definen instancias de los paquetes de manejo de archivos, según
el tipo de acceso que se vaya a utilizar.
use ArchTPersona_Sec;
Ahora se pueden declarar variables de tipo archivo secuencial:
MiArchivo : ArchTPersona_Sec.tipo_archivo;
23
Sintaxis de ADA
Ejemplo :
Ejemplo :
24
Sintaxis de ADA
Write( File => < nombre de variable >, Item => < nombre componente>);
¾ Otras funciones:
Los errores que pudieran producirse al intentar abrir un archivo pueden controlarse mediante
excepciones.
25