ada
Pacchi

Sintassi

• con Package_Name_To_Include;
• il pacchetto New_Package_Name rinomina Package_To_Rename;
• usa Package_Name;
• il pacchetto Parent_Name.Child_Name è

Osservazioni

Maggiori informazioni sui pacchetti

In Hello World , sei stato introdotto nel pacchetto Ada.Text_IO e come usarlo per eseguire operazioni di I / O all'interno del tuo programma. I pacchetti possono essere ulteriormente manipolati per fare molte cose diverse.

Rinominare : per rinominare un pacchetto, si utilizza la parola chiave renames in una dichiarazione di pacchetto, in quanto tale:

package IO renames Ada.Text_IO;

Ora, con il nuovo nome, puoi usare la stessa notazione Put_Line per funzioni come Put_Line (cioè IO.Put_Line ), o puoi semplicemente use con l' use IO . Ovviamente, use IO o IO.Put_Line userai le funzioni del pacchetto Ada.Text_IO .

Visibilità e isolamento : nell'esempio Hello World abbiamo incluso il pacchetto Ada.Text_IO utilizzando una clausola with . Ma abbiamo anche dichiarato che volevamo use Ada.Text_IO sulla stessa riga. La dichiarazione use Ada.Text_IO potrebbe essere stata spostata nella parte dichiarativa della procedura:

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

In questa versione, le procedure, le funzioni e i tipi di Ada.Text_IO sono direttamente disponibili all'interno della procedura. Al di fuori del blocco in cui viene utilizzato Ada.Text_IO , dovremmo utilizzare la notazione Ada.Text_IO per invocare, ad esempio:

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;

Questo ci permette di isolare l'uso ... delle dichiarazioni dove sono necessarie.

Relazione padre-figlio

Come un modo per suddividere i programmi Ada, i pacchetti possono avere i cosiddetti bambini. Anche questi possono essere pacchetti. Un pacchetto figlio ha un privilegio speciale: può vedere le dichiarazioni nella parte privata del pacchetto genitore. Un uso tipico di questa visibilità speciale è quando si forma una gerarchia di tipi derivati ​​nella programmazione orientata agli oggetti.

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;

Qualsiasi unità Ada guidata da with Orders; può dichiarare oggetti di tipo Bill e quindi chiamare operazioni Add , How_Much e Pay . Tuttavia, non vede i componenti di Bill e nemmeno di Orders.Bill , poiché la definizione completa del tipo è nascosta nella parte privata degli Orders . La definizione completa non è nascosta dai pacchetti figlio, tuttavia. Questa visibilità facilita l'estensione del tipo, se necessario. Se un tipo viene dichiarato nel pacchetto figlio come derivato da Bill , questo tipo di ereditarietà può manipolare direttamente i componenti di Bill .

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 è un pacchetto figlio di Orders . Type Ordered_By_Phone è derivato da Bill e include il suo componente record Sum .