ada
Paquets

Syntaxe

• avec Package_Name_To_Include;
• package New_Package_Name renomme Package_To_Rename;
• utilise le nom du paquet;
• package Parent_Name.Child_Name est

Remarques

Plus sur les forfaits

Dans Hello World , vous avez Ada.Text_IO le package Ada.Text_IO et comment l'utiliser pour effectuer des opérations d'E / S dans votre programme. Les paquets peuvent être manipulés pour faire beaucoup de choses différentes.

Renommer : pour renommer un package, vous utilisez le mot-clé renames dans une déclaration de package, en tant que tel:

package IO renames Ada.Text_IO;

Maintenant, avec le nouveau nom, vous pouvez utiliser la même notation en pointillés pour des fonctions telles que Put_Line (par exemple, IO.Put_Line ), ou vous pouvez simplement l' use avec use IO . Bien sûr, dire use IO ou IO.Put_Line utilisera les fonctions du package Ada.Text_IO .

Visibilité et isolation : Dans l'exemple Hello World, nous avons inclus le package Ada.Text_IO à l'aide d'une clause with . Mais nous avons également déclaré que nous voulions use Ada.Text_IO sur la même ligne. L' use Ada.Text_IO déclaration use Ada.Text_IO aurait pu être déplacée dans la partie déclarative de la procédure:

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

Dans cette version, les procédures, fonctions et types d' Ada.Text_IO sont directement disponibles dans la procédure. En dehors du bloc dans lequel Ada.Text_IO est déclaré, il faudrait utiliser la notation en pointillés pour invoquer, par exemple:

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;

Cela nous permet d'isoler l'utilisation… les déclarations à l'endroit où elles sont nécessaires.

Relation parent-enfant

Afin de subdiviser les programmes Ada, les packages peuvent comporter des enfants. Celles-ci peuvent être des paquets aussi. Un package enfant a un privilège spécial: il peut voir les déclarations dans la partie privée du package parent. Une utilisation typique de cette visibilité spéciale consiste à former une hiérarchie de types dérivés dans la programmation orientée objet.

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;

Toute unité Ada dirigée par with Orders; peut déclarer des objets de type Bill , puis appeler les opérations Add , How_Much et Pay . Cependant, il ne voit pas les composants de Bill , ni même de Orders.Bill , car la définition de type complète est masquée dans la partie privée de Orders . La définition complète n'est cependant pas masquée dans les packages enfants. Cette visibilité facilite l'extension de type si nécessaire. Si un type est déclaré dans le package enfant comme dérivé de Bill , ce type hérité peut manipuler directement les composants de 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 est un package enfant de Orders . Type Ordered_By_Phone est dérivé de Bill et inclut son composant d'enregistrement Sum .