Guía mínima de Ada 95

Unidades genéricas en Ada.

    Para utilizar el procedimiento "Algo" primero se deberán crear instancias para los tipos apropiados:
    ...
    procedure Algo_entero is new Algo(TElemento=>integer);
    procedure Algo_carácter is new Algo(character);

    Ahora, ya se pueden invocar los procedimientos "Algo_entero" y "Algo_carácter", según convenga:
    Algo_entero(30);
    Algo_carácter('a');
 

Paquetes genéricos

    En la implementación del paquete:
    package body nombre_del_paquete_genérico is
        --Zona de uso de los parámetros formales
    end nombre_del_paquete_genérico;

    Los parámetros formales se pueden emplear en la implementación del paquete (package body) sin más requerimientos.

    La forma de usar un paquete genérico es crear una instancia del paquete genérico en la que se especifiquen todos los parámetros formales requeridos. Esta sentencia tiene la forma:
    package nombre_instancia is new nombre_del_paquete_genérico(parámetros_actuales,...);

Parámetros formales

• Tipos privados: "private", "limited private", "tagged private" y "tagged limited private". La definición del tipo privado corresponde, en este caso, al llamador --no va a aparecer en la parte private, si estamos desarrollando un paquete--, (type Tipo is private;).
• Tipos escalares:
• Discretos. Se utiliza el símbolo "<>", (type TDiscreto is <>;).
• Enteros con signo. Se utiliza "range <>", (type TEntero is range <>;).
• Modulares. Se utiliza "mod <>", (type TModular is mod <>;).
• Reales en coma flotante. Se utiliza "digits <>", (type TRealFlotante is digits <>;).
• Reales en coma fija. Se utiliza "delta <>", (type TRealFijo is delta <>;).
• Decimales. Se utiliza "delta <> digits <>", (type TDecimal is delta <> digits <>;).
• Arrays. Hay que incluir como parámetros, el tipo de los elementos del array, el tipo del índice del array y el tipo array:

generic
 type TElemento is private;
 type Índice is (<>);
 type Vector is array (Índice range <>) of TElemento;
package P is
 ...
end P;
• Punteros. Hay que especificar el tipo puntero y el tipo apuntado:

generic
 type TNodo is private;
 type TP_Nodo is access TNodo;
package P is
 ...
end P;
• Subprogramas. Se utiliza la palabra "with" precediendo al protocolo del subprograma que se espera:

generic
 type TElemento is private;
 with procedure Acción(X : in TElemento);
procedure Iterar(Seq : in Secuencia_de_TElemento);
...
procedure Asignar_Elemento(X : in Item);
...
-- Es posible la siguiente instancia
procedure Asignar_Lista is
              new Iterar(TElemento => Item,
                          Acción => Asignar_Elemento);
Se puede especificar un nombre por defecto para el subprograma pasado por parámetro, utilizando "is nombre":
 with procedure Acción (X : in TElemento) is Escribir;

Si se quiere que el nombre por defecto sea el mismo que el del parámetro formal, se pondrá como nombre "<>":
 with procedure Acción (X : in TElemento) is <>;

En caso de especificar un nombre por defecto se podrá omitir el parámetro al instanciar la unidad.
 

• Paquetes. Se utiliza la palabra "with" precediendo a la instanciación del paquete que queremos como parámetro formal.

with package Nombre_formal is new Nombre_genérico Parte_formal_real;

Ejemplo:

  generic
      Tamaño : Natural := 10; -- Tamaño por defecto
      type Telemento is private; -- Tipo de dato a almacenar.
        -- El paquete no necesita conocer de Telemento mas que
        -- las operaciones que vienen a continuación
      with function "<"(X,Y: in Telemento) return Boolean is <>;
        -- Operación de comparación de elementos
      with procedure Accion(X: in Telemento);
        -- Operación que se aplica a un elemento

  package Lista_Ordenada is
      type Tlista is private; -- La implementación de la lista queda oculta
      procedure Insertar(X: in Telemento; L: in out Tlista);
        -- Inserta un elemento en la lista
      procedure Extraer(I: in Natural; L: in out Tlista);
        -- Extrae un elemento de la lista
      procedure Iterar(L: in Tlista);
        -- Recorre la lista aplicando una operación a cada elemento

  private  -- Estructura de datos de la lista
      type Contenedor is array (1..Tamaño) of Telemento;
      type Tlista is record
         Elementos : Contenedor;
         Num_Elementos : Natural := 0;
      end record;
  end Lista_Ordenada;

Fichero de implementación (*.adb)
-- Implementación de las operaciones de la lista ordenada

package body Lista_Ordenada is

  procedure Insertar(X: in Telemento; L: in out Tlista) is
      I : Natural;
  begin
      I := 1;
      -- Esquema de búsqueda para la localización de la posición
      while I <= L.Num_Elementos and then L.Elementos(I) < X loop
          I := I + 1;
      end loop;
      L.Num_Elementos := L.Num_Elementos + 1;--Posible Constrain Error
      if I < L.Num_Elementos then
          -- Se desplazan los elementos para insertar el nuevo
          for J in reverse I+1..L.Num_Elementos loop
              L.Elementos(J) := L.Elementos(J-1);
          end loop;
      end if;
      L.Elementos(I) := X;
  end Insertar;

  procedure Extraer(I: in Natural; L: in out Tlista) is
  begin
      -- Se desplazan los elementos para cubrir el hueco de la extracción
      for J in I..L.Num_Elementos-1 loop
          L.Elementos(J) := L.Elementos(J+1);
      end loop;
      L.Num_Elementos := L.Num_Elementos - 1;--Posible Constrain Error
  end Extraer;

  procedure Iterar(L: in Tlista) is
  begin
      -- Esquema de recorrido sobre la lista
      for J in 1..L.Num_Elementos loop
         Accion(L.Elementos(J));-- Se aplica la acción pasada como parámetro
      end loop;
  end Iterar;

 end Lista_Ordenada;

Fichero del programa principal (*.ada)
with Text_Io,Lista_Ordenada;
use Text_Io;

procedure Prueba_De_Contenedor is
    package Enteros_Io is new Integer_Io(Integer);
    use Enteros_Io;

    procedure Escribir_Elemento(X: in Integer) is
    begin
       Put(X);
       New_Line;
    end;
    -- Se crea una instancia del paquete genérico Lista_Ordenada, llamada
    -- Lista_Enteros, con un tamaño máximo de 20, los elementos que se almacenan
    -- son de tipo integer, la operación de comparación es el operador "<" de
    -- los integer (al no especificarlo se usa por defecto), como accion se pasa
    -- el procedimiento Escribir_Elemento
    package Lista_Enteros is new Lista_Ordenada(20,Integer,Accion => Escribir_Elemento);
    use Lista_Enteros ;

    L: Tlista;
begin
    for J in reverse 1..15 loop
        Insertar(J,L);
    end loop;
    Iterar(L);
end Prueba_De_Contenedor;