ada
Pakketjes

Syntaxis

• met Package_Name_To_Include;
• pakket New_Package_Name hernoemt Package_To_Rename;
• gebruik pakketnaam;
• pakket Parent_Name.Child_Name is

Opmerkingen

Meer over pakketten

In de Hello World maakte u kennis met het pakket Ada.Text_IO en hoe u het kunt gebruiken om I / O-bewerkingen binnen uw programma uit te voeren. Pakketten kunnen verder worden gemanipuleerd om veel verschillende dingen te doen.

Hernoemen : Om een pakket te hernoemen, gebruikt u het trefwoord renames in een pakketaangifte, als volgt:

package IO renames Ada.Text_IO;

Nu, met de nieuwe naam, kunt u dezelfde gestippelde notatie gebruiken voor functies zoals Put_Line (ie IO.Put_Line ), of u kunt het gewoon use met use IO . Als use IO of IO.Put_Line gebruikt, worden de functies uit het pakket Ada.Text_IO .

Zichtbaarheid & Isolation: In het Hello World voorbeeld betrekking heeft op het Ada.Text_IO pakket met behulp van een with clausule. Maar we hebben ook verklaard dat we use Ada.Text_IO op dezelfde regel wilden use Ada.Text_IO . De aangifte use Ada.Text_IO had naar het declaratieve gedeelte van de procedure kunnen worden verplaatst:

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

In deze versie zijn de procedures, functies en typen Ada.Text_IO direct beschikbaar in de procedure. Buiten het blok waarin gebruik Ada.Text_IO wordt gedeclareerd, zouden we de gestippelde notatie moeten gebruiken om bijvoorbeeld aan te roepen:

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;

Dit stelt ons in staat om de gebruiksverklaringen te isoleren waar ze nodig zijn.

Ouder-kind relatie

Als een manier om Ada-programma's onder te verdelen, kunnen pakketten zogenaamde kinderen hebben. Dit kunnen ook pakketten zijn. Een onderliggend pakket heeft een speciaal privilege: het kan de verklaringen zien in het privégedeelte van het bovenliggende pakket. Een typisch gebruik van deze speciale zichtbaarheid is bij het vormen van een hiërarchie van afgeleide typen in objectgeoriënteerd programmeren.

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;

Elke Ada-eenheid die wordt geleid with Orders; kan objecten van het type Bill declareren en vervolgens bewerkingen Add , How_Much en Pay How_Much . Het ziet echter niet de componenten van Bill , noch zelfs van Orders.Bill , omdat de volledige Orders.Bill verborgen is in het privégedeelte van Orders . De volledige definitie is echter niet verborgen voor onderliggende pakketten. Deze zichtbaarheid vergemakkelijkt indien nodig de uitbreiding van het type. Als in het onderliggende pakket een type wordt gedeclareerd als afgeleid van Bill , kan dit overgeërfde type de componenten van Bill rechtstreeks manipuleren.

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 is een onderliggend pakket met Orders . Type Ordered_By_Phone is afgeleid van Bill en bevat de recordcomponent Sum .