Weiter: 2.7.1 Typerweiterungen Hinauf: 2 TypenKlassen Zurück: 2.6 Limitierte Typen

2.7 Getaggte Typen und Typerweiterungen

    

In diesem Abschnitt behandeln wir die Kernpunkte von Ada, die die Objektorientierung betreffen, nämlich Vererbung  und (Laufzeit-)Polymorphismus  . Umfangreichere Beispiele zu diesem Thema finden sich in Kapitel 12.

Ein Record-Typ oder ein privater Typ, der das reservierte Wort tagged in seiner Deklaration beinhaltet ist ein getaggter Typ. Ein Objekt eines getaggten Typs trägt zur Laufzeit mit sich ein eindeutiges Tag . 

,,Guten Tag¡`, sagte der kleine Prinz.

Antoine de Saint-Exup'ery, 
,,Der Kleine Prinz``

Nur von getaggten Typen kann man andere Typen ableiten.   Dabei können zusätzliche Komponenten und primitive Operationen definiert werden. Der abgeleitete Typ wird Erweiterung des Vorgängertyps oder einfach Typerweiterung genannt. Jede Typerweiterung ist wieder ein getaggter Typ. Der Typ, von dem abgeleitet wird, heißt Vatertyp.   Es gibt also nur einfache Vererbung und keine mehrfache Vererbung.

Man kann folgende Eigenschaften von abgeleiteten Typen festhalten:

• Jede Klasse von Typen, die den Vatertyp beinhaltet, beinhaltet auch den abgeleiteten Typ.
• Wenn der Vatertyp ein elementarer Typ oder ein Array-Typ ist, dann ist die Menge der Werte des abgeleiteten Typs eine Kopie der möglichen Werte des Vatertyps. Für einen skalaren Typ ist der zugrunde liegende Bereich (range) des abgeleiteten Typs derselbe wie der des Vatertyps.
• Wenn der Vatertyp ein zusammengesetzter Typ, aber kein Array ist, dann sehen die Komponenten und Operationen, die für den abgeleiteten Typ deklariert sind, folgendermaßen aus:
  • Wenn im Zuge der Ableitung eine Diskriminante festgelegt wird, dann ist diese Diskriminante eine Komponente des abgeleiteten Typs; sonst alle im Vatertyp festgelegten Diskriminanten; im letzeren Fall spricht man davon, daß die Diskriminanten geerbt wurden.
  • Alle Komponenten (keine Diskriminanten) und Operationen des Vatertyps - man sagt dann, diese Komponenten wurden geerbt. Dabei werden bei den Operationen alle Parameter des Vatertyps systematisch durch Parameter des abgeleiteten Typs ersetzt.
  • Alle Komponenten, die im Erweiterungsteil festgelegt wurden.
• Der abgeleitete Typ ist limitiert genau dann, wenn der Vatertyp limitiert ist.
• Für jede vordefinierte Operation des Vatertyps gibt es eine vordefinierte Operation des abgeleiteten Typs.

Man sagt ein abgeleiteter Typ is direkt von seinem Vatertyp abgeleitet; er ist indirekt abgeleitet von jedem Typ, von dem sein Vatertyp abgeleitet ist. Durch Ableitung bildet sich somit ein Ableitungsbaum von getaggten Typen. Man nennt so einen Ableitungsbaum mit Wurzel T eine Ableitungsklasse von Typen für den Typ T.

Klassenumfassende Typen   (auch klassenweite Typen   genannt) sind für alle Ableitungsklassen definiert, deren Wurzel ein getaggter Typ ist. Man schreibt T'CLASS, um den klassenumfassenden Typ T zu bezeichnen. Der Name leitet sich her aus der Tatsache, daß ein formaler Parameter, dessen Typ T'CLASS ist, als aktuellen Wert ein Objekt eines beliebigen Typs aus der Ableitungsklasse von T annehmen kann. Wichtig ist, daß Operationen, die einen klassenweiten Typ als Parameter besitzen, keine primitiven Operationen sind.

Die Operationen, die auf einem getaggten Typ definiert sind, nennt man Dispatching-Operation.   Manchmal ist es möglich zur Compile-Zeit zu entscheiden, welche Operation eines getaggten Typs ausgeführt werden soll; meist jedoch kann diese Entscheidung erst zur Laufzeit gefällt werden. Das zur Laufzeit mit jedem Objekt eines getaggten Typs mitgeführte Tag ermöglicht es, diese Entscheidung zu treffen. Dabei ist vor allem wichtig, daß eine Operation nicht von mehr als einem getaggten Typ abhängig sein darf.

Für alle Subtypen S eines getaggten Typs T sind folgende Attribute definiert:

S'CLASS siehe oben

S'TAG gibt das Tag von $T$ zurück

Vorgriff: Objekte des Typs Tag KöNNEN MITTELS DES PACKAGES Ada.Tags BEARBEITET WERDEN.

package Ada.Tags is$$
type Tag is private;$$
$$
function Expanded_Name(T: Tag) return string;$$
function External_Tag(T: Tag) return string;$$
function Internal_Tag(External: string) return Tag;$$
$$
Tag_Error: exception;$$
private$$
$...$$$
end Ada.Tags;$$

Beispiele für getaggte Record-Typen sind:

type point is tagged$$
record$$
x,y: real := 0.0;$$
end record;$$
$$
type expression is tagged null record;$$
-hierwirderwartet,dassdieTyperweiterungenKomponentenhinzufuegen$$

• 2.7.1 Typerweiterungen
• 2.7.2 Erweiterungsaggregate
• 2.7.3 Abstrakte Typen
• 2.7.4 Access-Diskriminanten

Weiter: 2.7.1 Typerweiterungen Hinauf: 2 TypenKlassen Zurück: 2.6 Limitierte Typen