ada
Paquetes

Sintaxis

• con Package_Name_To_Include;
• package New_Package_Name cambia el nombre de Package_To_Rename;
• use Package_Name;
• paquete Parent_Name.Child_Name es

Observaciones

Más sobre Paquetes

En Hello World , se le presentó el paquete Ada.Text_IO y cómo utilizarlo para realizar operaciones de E / S dentro de su programa. Los paquetes pueden ser manipulados para hacer muchas cosas diferentes.

El cambio de nombre: Para cambiar el nombre de un paquete, se utiliza la palabra clave renames de una declaración del paquete, tales como:

package IO renames Ada.Text_IO;

Ahora, con el nuevo nombre, puede usar la misma notación de puntos para funciones como Put_Line (es decir, IO.Put_Line ), o simplemente puede use con use IO . Por supuesto, diciendo que use IO o IO.Put_Line usará las funciones del paquete Ada.Text_IO .

Visibilidad y aislamiento : en el ejemplo de Hello World , incluimos el paquete Ada.Text_IO con una cláusula with . Pero también use Ada.Text_IO que queríamos use Ada.Text_IO en la misma línea. El use Ada.Text_IO declaración use Ada.Text_IO podría haberse movido a la parte declarativa del procedimiento:

with Ada.Text_IO;
 
procedure hello_world is
   use Ada.Text_IO;
begin
   Put_Line ("Hello, world!");
end hello_world;

En esta versión, los procedimientos, funciones y tipos de Ada.Text_IO están directamente disponibles dentro del procedimiento. Fuera del bloque en el que se declara el uso de Ada.Text_IO , tendríamos que usar la notación de puntos para invocar, por ejemplo:

with Ada.Text_IO;
 
procedure hello_world is
begin
   Ada.Text_IO.Put ("Hello, ");       --  The Put function is not directly visible here
   declare
      use Ada.Text_IO;
   begin
      Put_Line ("world!");            --  But here Put_Line is, so no Ada.Text_IO. is needed
   end;
end hello_world;

Esto nos permite aislar las declaraciones de uso ... donde sean necesarias.

Relación padre-hijo

Como una forma de subdividir los programas de Ada, los paquetes pueden tener los llamados hijos. Estos también pueden ser paquetes. Un paquete secundario tiene un privilegio especial: puede ver las declaraciones en la parte privada del paquete principal. Un uso típico de esta visibilidad especial es cuando se forma una jerarquía de tipos derivados en la programación orientada a objetos.

package Orders is
   type Fruit is (Banana, Orange, Pear);
   type Money is delta 0.01 digits 6;
   
   type Bill is tagged private;

   procedure Add
     (Slip   : in out Bill;
      Kind   : in     Fruit;
      Amount : in     Natural);
   
   function How_Much (Slip : Bill) return Money;
   
   procedure Pay
     (Ordered : in out Bill;
      Giving  : in     Money);
   
private
   type Bill is tagged record
      --  ...
      Sum : Money := 0.0;
   end record;
end Orders;

Cualquier unidad de Ada que esté encabezada por with Orders; puede declarar objetos de tipo Bill y luego llamar a las operaciones Add , How_Much y Pay . Sin embargo, no ve los componentes de Bill , ni siquiera de Orders.Bill , ya que la definición de tipo completo está oculta en la parte privada de Orders . Sin embargo, la definición completa no está oculta en forma de paquetes secundarios. Esta visibilidad facilita la extensión de tipo si es necesario. Si un tipo se declara en el paquete secundario como derivado de Bill , entonces este tipo heredado puede manipular los componentes de Bill directamente.

package Orders.From_Home is
   type Address is new String (1 .. 120);
   
   type Ordered_By_Phone is new Bill with private;
   
   procedure Deliver
     (Ordered : in out Ordered_By_Phone;
      Place   : in     Address);

private
   type Ordered_By_Phone is new Bill with
      record
         Delivered : Boolean := False;
         To        : Address;
      end record;
end Orders.From_Home;

Orders.From_Home es un paquete secundario de Orders . El tipo Ordered_By_Phone se deriva de Bill e incluye su componente de registro Sum .