Ada Tour - Dokumentation

vor

5.1 Sprachelemente

5.1.1 Namen

Namen werden durch Bezeichner dargestellt und können für verschiedene Objekte vergeben werden.

z.B. für:
- Variablen,
- Pakete,
- Unterprogramme
- Prozesse und aller Arten von Eingangsaufrufen
- Zeiger,
- Objekte und ihrer Komponenten und Ausschnitten ,
- Objekte im Sinne der OOP,
- Attribute

Namen können dabei direkte Namen und Zeiger sein:

Beispiele für direkte Namen:

Feld_Limit : constant integer := 50; -- Name für eine Konstante

procedure Suche_Eintrag; -- Name für ein Unterprogramm

Beispiel für Zeiger:

Zeiger : access Integer; -- Deklaration von Zeiger
Zeiger := new Integer; -- Speicherplatzzuweisung fuer Zeiger
Zeiger.all := 25; -- Wertzuweisung

er.all := 25; -- Wertzuweisung

Darüber hinaus gibt es Namen, die ein Präfix (prefix <BNF>) haben, das selbst ein Name oder Zeiger auf einen Namen ist.

Eine indizierte Komponente bezeichnet
- eine Komponente einer Reihung (Feld) oder
- einen Eingangsaufruf an eine Eingangsfamilie (siehe Prozesse).

Indizierte Komponenten bestehen aus einem Präfix, also einem Namen, und einem beliebig komplexen Ausdruck in runden Klammern.(indexed_component <BNF>)

Wenn es sich bei dem Präfix um einen Reihungstyp handelt, dann muß innerhalb der Klammern die gleiche Anzahl Ausdrücke stehen, wie die Reihung Indexpositionen hat. Eine zweidimensionale Reihung (z. B. eine Matrix) hat zwei Indexpositionen, somit müssen zwei Ausdrücke in den Klammern stehen. Die indizierte Komponente bezieht sich auf die Komponente in der Reihung mit den angegebenen Indexwerten und muß auch den Typ dieser Komponente haben.

Beispiel:

with Text_IO;
procedure I_Liste is
   -- Instantiieren eines generischen Pakets zur Ausgabe von Integer
   package Int_io is new Text_IO.Integer_IO (Integer);

   type Listen_Index is range 1..50;
   -- Definition des Reihungstyps
   type Listen_Typ is array ( Listen_Index ) of Integer;

   Liste : Listen_Typ; -- Deklaration der Variablen fuer die Reihung

begin
   for I in Listen_Index loop
      Liste (I) := 2 * Integer(I); --
      -- Den einzelnen Feldern der Reihung werden Werte zugewiesen.
      -- Liste(I) = indizierte Komponente.
      -- Integer(I) = Typkonvertierung.
   end loop;
   for I in Listen_Index loop
      Int_IO.Put ( Liste (I) ); -- Die Felder der Reihung werden ausgegeben
      Text_IO.New_Line;
   end loop;
end;

Wenn das Präfix eine Familie von Eingangsaufrufen darstellt, darf nur ein Ausdruck innerhalb der Klammern stehen, weil eine Familie von Eingangsaufrufen nur eine eindimensionale Reihung sein darf.

Die indizierte Komponente bezeichnet den Eingangsaufruf mit dem angegebenen Index.

Wenn auf eine Reihung mittels Zeiger zugegriffen wird, so muß keine Zeigerdereferenzierung mit ".all" angegeben werden.zierung mit ".all" angegeben werden.

Selektierte Komponenten werden verwendet, um Eingänge, Familien von Eingängen, geschützte Unterprogramme, Komponenten aus Verbunden und Zielobjekte von Zugriffstypen zu identifizieren. Sie werden auch bei erweiterten Namen verwendet. (selected_component <BNF>)

Eine selektierte Komponente ist ein erweiterter Name, wenn das Präfix dazu dient, die Herkunft einer Komponente zu spezifizieren.

Beispiel:

with Text_IO; use Text_IO;
-- Ausgabefunktionen einbinden; enthält auch Put_Line
procedure PutLine is
   -- Definition einer eigenen Prozedur Put_Line
   procedure Put_Line (S:String) is
   begin
      Put ("# " & s & " #");
      New_Line;
   end;

begin
   Put_Line ("Eigenes Put_Line");
   -- Ruft das eigene Put_Line auf, da dieses zuletzt definiert wurde.
   Text_IO.Put_Line ("Original Put_Line");
   -- Ruft das Put_Line aus Text_IO auf, da der Name um den Namen des Paketes erweitert wurde.
end;

Eine selektierte Komponente, die kein erweiterter Name ist, ist entweder ein Objekt oder ein Wert eines zusammengesetzen Typs (z. B. Verbunde) oder ein Eingangsaufruf, eine Familie von Eingangsaufrufen oder ein geschütztes Unterprogramm.

Beispiel:

with Text_IO;
procedure Person is

   type Personen_Typ is record -- Definition eines Verbundtyps
      Name, Vorname: String (1..20) := (others => ' ');
      Alter: Natural;
   end record;

   Person_1: Personen_Typ; -- Deklaration des Verbundes

begin
   Person_1.Name (1..7) := "Mueller"; -- Zuweisen von Werten
   Person_1.Vorname (1..6) := "Gustav";
   Person_1.Alter := 25;
   -- Ausgeben der Werte:
   Text_IO.Put_Line (Person_1.Name & ", " & Person_1.Vorname & ": " & Natural'Image (Person_1.Alter) );
end;

Wenn auf eine selektierte Komponente mittels Zeiger zugegriffen wird, so muß keine Zeigerdereferenzierung mit ".all" angegeben werden.

Ein Ausschnitt ist ein Teilstück einer eindimensionalen Reihung und ist selbst wieder eine eindimensionale Reihung. Hierdurch können Teile einer Reihung oder einer Zeichenkette kopiert werden. (slice <BNF>)

Das Präfix kann von jedem beliebigen Reihungstyp sein. Das Ziel der Zuweisung muß aber vom gleichen übergeordneten Reihungstyp sein wie das Präfix. Ein Ausschnitt aus einer Reihung mit Zeichen kann also nicht einer Reihung von Zahlen zugewiesen werden.

Ein diskreter Bereich (discrete_range <BNF>) ist eine ganzzahlige Bereichsangabe, die im Definitionsbereich der entsprechenden Reihung liegen muß.

Selbst wenn ein Ausschnitt nur aus einem Element besteht, ist der Ausschnitt eine Reihung, so daß das Ziel der Zuweisung auch eine Reihung sein muß.

Beispiel 1:

...
subtype Alphabet_Groesse is integer range 1..26; -- Groesse der Reihung
type Alphabet_Typ is array ( Alphabet_Groesse ) of character; -- Definition der Typs

Alphabet : Alphabet_Typ; -- Deklarieren zweier Variablen
Einige_Buchstaben : Alphabet_Typ;
...
Einige_Buchstaben ( 1 .. 5 ) := Alphabet ( 22 .. 26 ); -- Die letzten 5 Buchstaben des Alphabets
...

Beispiel 2:

...
type Tage_pro_Woche is range 1 .. 7; -- Anzahl Tage pro Woche
subtype Arbeitstage is Tage_pro_Woche range 1 .. 5; -- davon Arbeitstage
subtype Tage_String is String ( 1 .. 2 ); -- String fuer 2 Zeichen
type Wochentage_Typ is array (Tage_pro_Woche) of Tage_String; -- Strings fuer eine Woche

Wochentage : Wochentage_Typ := ("Mo", "Di", "Mi", "Do", "Fr", "Sa", "So" ); -- Setzen der Wochentage

Einige_Tage : Wochentage_Typ;
...
Einige_Tage ( Arbeitstage ) := Wochentage ( Arbeitstage ); -- Die Arbeitstage der Woche kopieren
...

Beispiel 3:

   Name : String(1 .. 40);
begin
   Name(1 .. 39) := Name(2 .. 40); -- erstes Zeichen löschen und restliche Zeichen nachziehen

   Name(2 .. 40) := Name(1 .. 39); -- letztes Zeichen löschen und restliche Zeichen um eins nach
                                   -- rechts verschieben

   Name(1 .. 1) := "X"; -- Ausschnitt vom Typ String
   Name(1) := ’X’; -- Indizierte Komponente vom Typ Character
end;

Attribute sind Eigenschaften von Objekten und Typen und liefern Informationen über Wertebereiche und Speicheradressen und über einige andere Eigenschaften von Objekten.

Es gibt aber auch Attribute, die Funktionen sind und z. B. dazu dienen, Werte zu konvertieren, z. B. Zahlen in Zeichenketten. (attribute_reference <BNF>)

Das Präfix kann entweder eine Variable oder aber ein Typ sein. Dieses ist abhängig von der Art des jeweiligen Attributs. Attribute beziehen sich auf Werte, Objekte, Unterprogramme oder eine andere Art von Programmobjekt.

Der Ausdruck in den Klammern des Attribut-Bezeichners muß (sofern vorhanden) ein diskreter Typ sein. Eine vollständige Liste der Attribute ist in der Anlage K des LRM enthalten.

Beispiel:

with Text_IO;
procedure Attr is
   Liste: array (5..10) of Integer := (50, 60, 70, 80, 90, 100); -- Reihung mit Werten

begin
   Text_IO.Put_Line ("Anfang: " & Integer'Image(Liste'First));
   -- Index des ersten Elements
   Text_IO.Put_Line ("Ende: " & Integer'Image(Liste'Last));
   -- Index des letzten Elements
   Text_IO.Put_Line ("Groesse: " & Integer'Image(Liste'Length));
   -- Groesse der Reihung
   Text_IO.Put_Line ("Werte:");
   for I in Liste'Range loop -- Range ist 5..10
      Text_IO.Put_Line (Integer'Image (Liste (I) ) ); -- => Liste aller Werte
   end loop;
end;

Wenn auf ein Objekt, dessen Attribut erfragt werden soll, mittels Zeiger zugegriffen wird, so muß keine Zeigerdereferenzierung mit ".all" angegeben werden.

Anhand des Namens läßt sich nicht erkennen, um welche Art von Programmobjekt es sich handelt.

Ein Programmierer sollte darauf achten, Namen zu verwenden, durch die die Art des Objekts erkenntlich ist.

So kann z. B. ein Unterprogrammname immer den Aufbau einer Aufforderung oder eines Befehls haben, für Funktionen bieten sich auch Verben an.

Diese Art der Namensgebung sollte vor Projektbeginn festgelegt und dann konsequent angewendet werden.

zurück

vor

Index

nach oben