ada
Pakete

Syntax

• mit Package_Name_To_Include;
• package New_Package_Name benennt Package_To_Rename um;
• Verwende Package_Name;
• Paket Parent_Name.Child_Name ist

Bemerkungen

Mehr zu Paketen

In der Hello World wurden Sie mit dem Paket Ada.Text_IO und Ada.Text_IO , wie Sie es verwenden können, um E / A-Vorgänge in Ihrem Programm auszuführen. Pakete können weiter manipuliert werden, um viele verschiedene Aufgaben auszuführen.

Umbenennen : Um ein Paket umzubenennen, verwenden Sie das Schlüsselwort renames in einer Paketdeklaration:

package IO renames Ada.Text_IO;

Jetzt, mit dem neuen Namen, können Sie die gleiche Punktnotation für Funktionen wie verwenden Put_Line (dh IO.Put_Line ), oder Sie können einfach use es mit use IO . IO.Put_Line use IO oder IO.Put_Line werden IO.Put_Line die Funktionen aus dem Paket Ada.Text_IO .

Sichtbarkeit und Isolation : Im Hello World- Beispiel haben wir das Ada.Text_IO-Paket mit einer with Klausel eingefügt. Wir haben aber auch erklärt, dass wir use Ada.Text_IO in derselben Zeile verwenden wollen. Die use Ada.Text_IO Deklaration konnte in den deklarativen Teil der Prozedur verschoben werden:

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

In dieser Version sind die Prozeduren, Funktionen und Typen von Ada.Text_IO direkt in der Prozedur verfügbar. Außerhalb des Blocks, in dem Ada.Text_IO deklariert ist, müssten wir zum Beispiel die gepunktete Schreibweise verwenden:

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;

Dies ermöglicht es uns, die Verwendungserklärungen dahin zu isolieren, wo sie notwendig sind.

Eltern-Kind-Beziehung

Zur Unterteilung von Ada-Programmen können Pakete so genannte Kinder haben. Dies können auch Pakete sein. Ein untergeordnetes Paket hat ein besonderes Privileg: Es kann die Deklarationen im privaten Teil des übergeordneten Pakets sehen. Eine typische Anwendung dieser besonderen Sichtbarkeit ist die Bildung einer Hierarchie abgeleiteter Typen in der objektorientierten Programmierung.

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;

Jede Ada-Einheit, die with Orders; geleitet wird with Orders; kann Objekte vom Typ Bill deklarieren und dann die Operationen Add , How_Much und Pay How_Much . Es werden jedoch weder die Komponenten von Bill noch von Orders.Bill , da die vollständige Typdefinition im privaten Teil von Orders verborgen ist. Die vollständige Definition wird jedoch nicht von untergeordneten Paketen ausgeblendet. Diese Sichtbarkeit erleichtert bei Bedarf die Typenerweiterung. Wenn ein Typ , bei dem Kind Paket deklariert wird , wie abgeleitet von Bill , dann kann dieser Vererbungstyp manipuliert Bill ‚s - Komponenten direkt.

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 ist ein Orders.From_Home Paket von Orders . Der Typ Ordered_By_Phone wird von Bill abgeleitet und enthält die Datensatzkomponente Sum .