Transcript Ada 95
Ada 95
Eine Einführung
© Günter Riedewald
Die Folien sind eine Ergänzung des Einführungskursus Ada 95 und nur für den internen Gebrauch konzipiert.
I Historisches
Ausgangssituation 1974, DoD der USA: 50 % aller Computeranwendungen sind eingebettete Anwendungen Nutzung von mehr als 450 Programmiersprachen Ständig wachsende Komplexität der Systeme und wachsende Kosten Neue Technik erfordert weitere neue Programmiersprachen
Ziel
: Entwicklung 1 höheren Programmier sprache für eingebettete Systeme
Entwicklungszeit
: 1975 – 1983 Ada 83 ANSI-Standard 1983, ISO-Standard 1987
Aufwand
: Erarbeitung von Anforderungen an die neue Sprache Bewertung von 26 existierenden Sprachen
Pascal
, ALGOL, PL/1 als Basis der neuen Sprache Bewertung des neuen Entwurfs durch 80 Teams
Name der Sprache
: Ada von Augusta
Ada
Byron (1815-1851), Programmiererin der Analytical Engine von Ch. Babbage
Bedeutende Sprachkonzepte in
Ada 83: Paket-Konzept (package): Zusammenfassung von Datentypen, Datenstrukturen und Prozeduren Grundlage für objektbasierte Programmierung Generische Einheiten (generics): Muster für Pakete und Prozeduren Ausnahmebehandlung Parallelarbeit mit Rendezvoustechnik Echtzeitprogrammierung
Bewertung
: Zeitgemäße Sprachkonzepte und Konzepte der Softwaretechnik Compiler nur mit Zertifikat erlaubt Softwareportabilität gute Sicherheitsprobleme Nichtakzeptanz aus politischen Gründen
Weiterentwicklung zu
Ada 95: Revision von Ada 83 Einführung neuer Konzepte: - Nutzung des Monitorkonzepts (protected types and procedures) in der Prozesskommunikation - Schnittstellen zu anderen Programmier sprachen OO Konzept über Typkonzept und Paket konzept (Programmierung durch Erweiterung) - Hierarchische Bibliotheken
Wichtige Prinzipien
: Gute Lesbarkeit Strenge Trennung von Schnittstelle und Implementierung Strenge Typkontrolle und interne Konsistenzüberprüfung Synchronisationskonzepte für Prozesskommunikation Programmierer-gesteuerte dynamische Speicherverwaltung, Initialisierung, Zuweisung und Beendigung für nutzergesteuerte Objektbehandlung
II Programmstruktur II.1 Programmeinheiten
Unterprogramm
: Prozedur, Funktion
Paket
: weiterentwickelter Modul, geeignet für Klassenkonzept
Task
:Programmeinheit für parallele Berechnungen
Geschützte Einheit
: entspricht Monitor zur Synchronisation paralleler Einheiten
Generische Einheit (Paket, Unterprogramm)
: parametrisierte Mustereinheit Ada-
Programm
: Anzahl von Paketen und Hauptprozedur (
main
)
Übersetzungseinheit
: Kontext gefolgt von Deklaration/Körper eines Unterprogrammes oder Pakets
II.2 Pakete (packages)
Paket
: Grundeinheit von Ada-Programmen bestehend aus
Spezifikation
(
Deklaration
) und
Körper Paketspezifikation
:
package
is
private
end
[
Beispiel
:
package
Rational_Numbers
is type
Rational
is record
Numerator: Integer; Denominator: Positive;
end record
;
function
´´=´´(X, Y: Rational)
return
Boolean; ...
end
Rational_Numbers;
Beispiel
:
package
Keller
is
-- Typvereinbarungen
type
Keller
is private
; -- UP-Vereinbarungen
function
leer(K: Keller)
return
Boolean; -- Test auf leeren Keller
procedure
push(K:
in out
Keller; E:
in
Integer); -- Abspeicherung eines Elements im Keller
procedure
pop(K:
in out
Keller); -- Entfernung des Elements an der Kellerspitze
function
size(K: Keller)
return
Natural; -- Anzahl der Elemente im Keller -- Ausnahmesituationen Keller_Ueberlauf:
exception renames
Storage_Error; Leerer_Keller:
exception
;
private type
Komponente;
type
Komponenten_Zeiger
is access
Komponente;
type
Komponente
is record
Information: Integer; Naechste: Komponenten_Zeiger;
end record
;
type
Keller
is record
Anfang: Komponenten_Zeiger :=
null
; Komponentenzahl: Natural := 0;
end record
;
end
Keller;
Paketkörper
:
package body
is
begin
end
[
Beispiel
:
package body
Rational_Numbers
is procedure
Same_Denominator(X, Y:
in out
Rational)
is begin
...
end
Same_Denominator;
function
´´=´´(X, Y: Rational)
return
Boolean
is
U: Rational := X; V: Rational := Y;
begin
Same_Denominator(U, V);
return
U.Numerator = V.Numerator;
end
´´=´´; ...
end
Rational_Numbers;
Sichtbarkeit
von Konstrukten: Körperinhalte sind nicht sichtbar.
Deklarationsinhalte sind sichtbar.
Private oder beschränkt private Typen haben eine sichtbare Bezeichnung, aber ihre Struktur ist nicht sichtbar.
Privater Typ: = /= und := sind als bitweise Operationen automatisch zur Verfügung.
Beschränkt privater Typ: = und /= sind automatisch vorhanden.
Vor- und Nachteile von
Paketverschachtelungen
: + Zerlegung komplexer Systeme in Hierarchie von Untersystemen + Klärung von Paketbeziehungen bzgl. Sichtbarkeit - Erschwerte Arbeit an einzelnen Paketen einer Hierarchie Kleine Änderungen an einem Paket einer Hierarchie können gesamte Hierarchie beeinflussen Konzept des
Kindpakets
Kindpaket
: Konzeptuell Bestandteil des Elternpakets, aber physisch getrennt und separat übersetzbar Deklaration:
package
is
...
Möglichkeit der Verwendung privater Pakete Anwendung: Paketspezialisierung (z.B. bei objektorientierter Programmierung)
Sichtbarkeit: Deklarationen X öffentlich privat Körper X.Y
öffentlich privat
Beispiel
: Fortsetzung Keller Kindpaket für sortierten Keller
package
Keller.Sortierung
is procedure
Sortiere_Keller(Ziel, Quelle:
in out
Keller);
end
Keller.Sortierung;
II.3 Unterprogramme
Unterprogramme
: Prozeduren, Funktionen (einschließlich aufzählbare Literale und Operatoren) Trennung in Spezifikation (Deklaration) und Körper
Unterprogrammspezifikation
: Prozedur:
procedure
function
return
Parameterspezifikation
:
Modus
: [
in
]: für Eingabeparameter
out
: für Ausgabeparameter
in out
: für Parameter, die Ein- und Ausgabeparameter sind Der Ausdruck in der Parameterspezifikation dient dem Setzen eines Anfangswertes und kann durch den aktuellen Parameter überschrieben werden.
Beispiele
:
procedure
Travers_Tree;
procedure
Increment(X:
in out
Integer);
function
Next_Frame(K: Positive)
return
Frame;
function
´´*´´(Left, Right: Matrix)
return
Matrix;
procedure
Print_Header(Pages:
in
Header:
in
Natural; Line := (1..Line
´Last ´´); Center:
in
Boolean := True);
Unterprogrammkörper
:
is
begin
end
[
Beispiel
:
procedure
Push(S:
in out
Stack; E:
in
Element_Typ)
is begin if
S.Index = S.Size
then raise
Stack_Overflow;
else
S.Index := S.Index + 1; S.Space(S.Index) := E;
end if
;
end
Push;
Unterprogrammaufrufe
:
Aktueller Parameter
:
Schlüsselparameter)
Zuordnung
aktueller Parameter zu formalen Parametern: Durch Position Durch Name (bei Schlüsselparametern)
Wertebestimmung
für Parameter: Durch Initialisierungsausdruck in Spezifikation Durch Zuordnung aktueller zu formalen Parametern
Beispiele
: Traverse_Tree; Print_Header(128, Title, True); Print_Header(128, Header Title, Print_Header(Header True, Pages 128); Center True); Title, Center
Deklaration
:
procedure
Activate( Process:
in
Process_Name; After:
in
Process_Name := No_Process; Wait:
in
Duration := 0.0; Prior:
in
Boolean := False);
Aufruf
: Activate(X, Wait 60.0, Prior True);
Deklaration
:
procedure
Set(Tint:
in
Color);
procedure
Set(Signal:
in
Light);
Aufruf
: Set(Signal Red); (Red ist in den beiden Aufzählungstypen Color und Light enthalten.)
return-
Anweisung
:
return
[
Ein Funktionskörper muss mindestens 1 return-Anweisung mit Ausdruck enthalten.
Im Falle von Prozeduren dient die Anweisung zum Verlassen der Prozedur. Sie liefert dann keinen Wert und der Ausdruck fehlt.
Bemerkung
: Operatoren werden als Funktionen definiert. Ihre Anwendung erfolgt in gewohnter Infixschreibweise.
Beispiel
:
Deklaration
:
function
´´+´´(Left, Right: Matrix)
return
Matrix;
Anwendung
: A := B + C;
II.4 Generische Einheit
Generische Einheit
(Paket oder Unterprogramm): Muster zum Ableiten eines Pakets bzw. Unterprogrammes (Instanz der generischen Einheit)
Generische
Unterprogramm(Paket)deklaration:
Generische formale Parameter
:
generic
private
beliebiger Typ mit := und =
limited private tagged private
beliebiger Typ beliebiger Erweiterungstyp mit := -
tagged limited private
Erweiterungstyp beliebiger
Beispiel
: generischer Keller als Datenkapsel
generic
Size: Positive;
type
Item
is private
;
package
Stack
is procedure
Push(E:
in
Item);
procedure
Pop(E:
out
Item); Overfow, Underflow:
exception
;
end
Stack;
package body
Stack
is type
Table
is array
(Positive
range
<>)
of
Item; Space: Table(1..Size); Index: Natural := 0;
procedure
Push(E:
in
Item)
is begin if
Index >= Size
then raise
Overflow
end if
; Index := Index + 1; Space(Index) := E;
end
Push;
procedure
Pop(E:
out
Item)
is begin if
Index = 0
then raise
Underflow;
end if
; E := Space(Index); Index := Index – 1;
end
Pop;
end
Stack;
Instantiierung
: Integer-Stack mit maximal 200 Elementen
package
Stack_Int
is new
Stack(Size Item 200, Integer);
II.5 Übersetzungseinheit
Übersetzungseinheit
:
Kontextklauselfolge
:
with
use
Bibliothekselement
: Paketdeklaration Paketkörper Unterprogrammdeklaration Unterprogrammkörper Umbenennung eines Bibliothekselements
III Anweisungen
Anweisung einfach zusammengesetzt
null
Zuweisung
goto return requeue abort raise
Verzögerung
entry
-Aufruf Prozeduraufruf
exit code if loop accept case select
Block
Zuweisung
:
Beispiel
: A: String(1..31); B: String(3..33); ...
A := B; A(1..9) := ´´tar sauce´´; A(4..12) := A(1..9);
if-Anweisung
:
if
then
elsif then > else end if ; Ausführung der Anweisungsfolge zur ersten gültigen Bedingung (von oben beginnend) Keine Bedingung gültig: Abarbeitung der Anweisungsfolge nach else Beispiel : if Line_Too_Short then raise Layout_Error elsif Line_Full then New_Line; Put(Item); else Put(Item); end if ; case-Anweisung : case is end case ; Voraussetzungen : - Der Ausdruck ist von einem diskreten Typ. Alle Auswahllisten der Alternativen müssen den gesamten Wertebereich des Typs abdecken. Alternative : when others Beispiel : case Today is when Mon when when Compute_Initial_Balance; Fri Compute_Closing_Balance; Tue..Thu when Generate_Report(Today); Sat..Sun null ; end case ; Schleifen : Einfache Schleife (Endlosschleife) : [ loop end loop [ Bemerkung : Terminierung ist nur über eine exit - oder exit when Klausel möglich. while-Schleife (bedingte Schleife) : [ loop while end loop [ for-Schleife (Laufschleife) : [ for loop end loop [ Schleifenparameterspezifikation : in [ reverse ] Abarbeitung : Wiederholte Abarbeitung der Anweisungsfolge für jeden Wert des Typs nach vorheriger Zuweisung an den Schleifenparameter. Die Werte des Schleifenparameters müssen aufsteigend bzw. absteigend (im Falle von reverse ) sein. Sie können durch die Anweisungsfolge nicht geändert werden und sind außerhalb der Schleife nicht zugreifbar. Beispiele : with Text_IO, Integer_Text_IO; use Text_IO, Integer_Text_IO; procedure Print_Squares is X: Integer; begin loop Get(X); exit when X = 0; Put(X*X); New_Line; end loop ; end Print_Squares; while N < 20 loop Put(N); N := N + 1; end loop ; for Count in 1..20 loop Put_Line( ´´Hello´´); end loop ; for I in reverse 10..1 ... 10..1 ist ein leerer Bereich. Die Schleife bewirkt deshalb nichts. for I in reverse 1..10 ... Die Abarbeitung beginnt mit I = 10 und endet mit I = 1. Blockanweisung : [ declare begin end [ exit-Anweisung : exit [ when Wirkung : Verlassen der bezeichneten Schleife oder –bei fehlendem Namen- der innersten Schleife, die die Anweisung enthält, bedingt durch Erfüllung der Bedingung Beispiel : Schleife_1: loop ... Schleife_2: loop ... exit when ...; ... exit Schleife_1 when ...; end loop Schleife_2; ... end loop Schleife_1; ... goto-Anweisung : goto Zielanweisung : << >> Voraussetzung : Die innerste Anweisungsfolge, die die Zielanweisung enthält, muss auch die Sprunganweisung enthalten. Zweck von Typen : Vereinbarung zulässiger Wertebereiche und Operationen in diesen Bereichen Verhinderung und Aufdeckung von Programmierfehlern Festlegung von Datenrepräsentationen Informationen für Speicherorganisation (Compiler, Laufzeitsystem) Alle Zeiger Elementar Skalar Zusammengesetzt Diskret Aufzählung Integer Real Gleitkomma Festkomma Vorzeichenbeh. Modular Gewöhnlich Dezimal Zusammengesetzt Feld Zeichenkette Verbund Weitere Erweiterung Task Geschützt Skalare Typen: bezeichnen geordnete Datenstrukturen besitzen vordefinierte Vergleichsoperationen Bereichsdefinition : range range Attribute : S skalarer Typ S ´First S ´Last S ´Range untere Bereichsgrenze von S obere Bereichsgrenze von S S ´First..S´Last S ist ein diskreter Typ: S ´Pos S ´Val Position eines Wertes Wert auf einer Position S ´Pred/S´Succ Vorgänger/Nachfolgerwert Definition : ( Überladung von Literalen bei eindeutiger Identifizierung des Typs möglich Beispiele type Color is (White, Red, Yellow, Green, Blue, Brown, Black); type Light is (Red, Amber, Green); Zeichentypen Vordefiniert sind hier Character (ISO 8859-1) und Wide_Character (ISO 10646). Boolean Dieser Typ enthält die gewohnten Werte False und True, wobei False < True, und die gewohnten Operationen ( or , and, not , xor ) sowie die Abkürzungsoperationen and then und or else . Er ist im Paket Standard vordefiniert. Der Typ Integer mit den gewohnten Operationen und mit durch das jeweilige Rechnersystem bestimmten Grenzen (System.Min_int..System.Max_Int) ist vordefiniert. Vordefiniert sind ebenfalls die Untertypen Natural und Positive: subtype Natural is Integer range 0..Integer ´Last; subtype Positive is Integer range 1..Integer ´Last; Weitere Integertypen: Vorzeichenbehaftete Integer : range Modularer Typ: mod ; A statischer Integerausdruck von positivem Wert (W) Definierter Bereich 0..W - 1 Wurzeltyp (Alle Integertypen sind davon abgeleitet.): root_integer Universeller Typ (Typ der Integerliterale): universal_integer Beispiele : type Column is range 1..72; subtype Up_To_K is Column range 1..K; C: Column := 25; C1: Column := 0; nicht zulässig Ausnahme Reelle Typen sind eine Approximation der reellen Zahlen mit relativen bzw. absoluten Fehlergrenzen. Wurzeltyp : root_real Universeller Typ : universal_real Universeller Typ der Festkommaklasse : universal_fixed Gleitkommatypen Rechnerrepräsentation : +/- Mantisse* Basis Exponent mit Definition der relativen Genauigkeit : digits range Vordefinierter Standardtyp : Float im Paket Standard (entspricht dem Gleitkommatyp des Rechners) Beispiele : type Mass is digits 7 range 0.0..1.0E35; type Reell is digits 8; Festkommatypen Angabe einer absoluten Genauigkeit (Maximaldistanz zwischen zwei benachbarten zu unterscheidenden Werten) Unterteilung in Gewöhnliche Festkommatypen (Binärrepräsentation) Dezimale Festkommatypen (Dezimalrepräsentation) Gewöhnliche Festkommatypen Definition : delta range Wertemenge : ganzzahlige Vielfache von small in den angegebenen Bereichsgrenzen mit small = 2 i Wert(A) Beispiel : type Fraction is delta 2.0**(-15) range –1.0..1.0; Definiert alle rellen Zahlen r = n*2 -15 , wobei n ganzzahlig ist und -1.0 r 1.0 . Dezimale Festkommatypen Definition : delta digits range Bedingung: -(10 Wert(D) -1)*Wert(A) (10 Wert(L) Wert(D) Wert(R) -1)*Wert(A) Wertebereich : ganzzahlige Vielfache von small im angegebenen Bereich mit small = Wert(A) = 10 i Beispiel : type Money is delta 0.01 digits 15; Definiert den Bereich der reellen Zahlen -(10 15 -1)*10 -2 .. (10 15 -1)*10 -2 , wobei die reellen Zahlen ganzahlige Vielfache von 10 -2 sind. Attribute (Auswahl) : S ´Small S ´Delta small vom Typ universal_real delta (Wert(A)) vom universal_real-Typ S ´Fore minimale Anzahl von Zeichen vor dem Dezimalpunkt einschließlich Vorzeichen S ´Aft Anzahl der Dezimalziffern nach dem Dezimalpunkt Unterteilung von Objekten : Vereinbarte Objekte: durch Vereinbarungen eingeführt und weitestgehend an Programmstruktur und –ablauf gebunden; Abspeicherung bevorzugt im Keller Dynamische Objekte: dynamisch an fast allen Programmstellen erzeugbar und löschbar; Abspeicherung auf der Halde Zugriff zu dynamischen Objekten : über vereinbarte und typisierte Zeiger X w vereinbartes dynamisch erzeugtes Zeigerobjekt Objekt w Wert vom für X festgelegten Typ Adresse des dynamisch erzeugten Objekts Definition : access [ all | constant ] all oder constant werden im Falle des allgemeinen Zugriffs verwendet: - all : Das Bezugsobjekt kann geändert werden. - constant : Das Bezugsobjekt darf nicht geändert werden. Anfangswert von Zeigern: null Bezugsobjekte (gezeigte oder referierte Objekte): Auf der Halde dynamisch erzeugte Objekte Durch aliased gekennzeichnete Objekte bei allgemeinen Zeigern Bezeichnung: all Unterscheide Voraussetzung: A, B Zeigervariablen vom gleichen Typ A a B b Zeigerzuweisung A := B : A B a b Entreferenzierte Zuweisung A. all := B. all : A B a b b Unterscheide Allgemeiner Zugriff : - Zeigerkennzeichnung durch all oder constant - Bezugsobjekt dynamisch oder durch aliased gekennzeichnet - Adressenbestimmung: : Bezugsobjekt durch Allokation geschaffen new Beispiele : type Zeiger1 is access all Integer; N: aliased Integer; Z1: Zeiger1 := new Integer; Z2: Zeiger1 := N ´Access; type Zeiger2 is access constant Integer; N: aliased Integer := 5; Z3: Zeiger2 := N ´Access; Z3. all := 3; nicht erlaubt!!! type Cell; type Link is access Cell; type Cell is record Value: Integer; Succ, Pred: Link end record ; Head: Link := new Cell ´(0, null , null ); Next: Link := Head.Succ; Definition : Eingeschränkte Felder: - array ( of range Uneingeschränkte Felder: - array ( of Unbeschränkter Bereich : range <> - Indexeinschränkung (bei Vereinbarung oder Zuweisung realisiert): ( Objektvereinbarung : Ein Feldtyp (eingeschränkt!) kann auch erst im Zusammenhang mit einer Objektvereinbarung eingeführt werden. aliased ] [ constant ] array ( of Reihungskomponente (Feldkomponente): Attribute : A Feldtyp A ´First untere Grenze des ersten Indexbereichs A ´First(N) untere Grenze des N. Indexbereichs A ´Last A ´Range A ´Length obere Grenze des ersten Indexbereichs A ´First..A´Last Komponentenanzahl Bemerkungen : In Ada unterscheidet man mehrdimensionale Felder (z.B. Matrix) von ineinandergeschachtelten Feldern (z.B. Vektor von Vektoren). Felder können durch Aggregate auf einfache Weise initialisiert werden. Beispiele : type Matrix is array Integer range <>) of (Integer range <>, Real; type Line Character; is array (1..Max_Line_Size) of Board: Matrix(1..8, 1..8); Inverse: Matrix(1..N, 1..N); Page: array (1|50 2..49 (Positive range <>) of Line := Line ´(1|Line´Last ´+´, others Line ´(1|Line´Last ´|´, others ´-´), ´´)); ergibt 1 Line ´Last 1 2 49 50 + - - - ... | ... | ... ... + - - - ... - - - - - + | | - - - - - + Zeichenketten Zeichenketten sind eindimensionale Felder mit Elementen eines Character-Typs. Vordefinierte Zeichenkettentypen : type String is array (Positive range <>) of Character; type Wide_String is array (Positive range <>) of Wide_Character; Beispiele : Stars: String(1..120) := (1..120 ´*´); Ninety_Six: constant Roman := ´´XCVI´´; Definition : [[ abstract ] tagged ][ limited ] record end record ; Komponente : Leere Komponente : null Normalfall : Variantenteil : case is end case ; Variante : when others Bedingung : Die durch die Auswahllisten definierten Werte dürfen sich nicht überlappen und müssen eine völlige Überdeckung der möglichen Werte liefern. Beispiele : type Complex is record Re: Real := 0.0; Im: Real := 0.0; end record ; type Person is record Birth: Date; Name: String(1..20) := (1..20 ´´); end record ; John: Person; John.Birth := (19, Aug, 1937); John.Name(1..4) := ´´John´´; type Device is (Printer, Disk, Drum); type State is (Open, Closed); type Peripheral(Unit: Device := Disk) is record Status: State; case Unit is when Printer when others Line_Count: Integer range Cylinder: Cylinder_Index; 1.. Page_Size; Track: Track_Number; end case ; end record ; Definierte Verbunde: Für Printer: Status Line_Count Für Disc und Drum: Status Cylinder Track Vereinbarung: Writer: Peripheral(Unit Printer); Definition : type is Arten von Typen in Ada : Datentypen mit Bereichsangaben Untertypen Parametrisierte Typen Abgeleitete Typen Erweiterungstypen Klassenweite Typen Abstrakte Typen Universelle Typen Untertypen Deklaration : subtype is Operationen : Der Untertyp erbt die Operationen des Obertyps. Der Untertyp kann zusätzliche Operationen besitzen. Obertyp und alle seine Untertypen sind operationsverträglich soweit die Bereichs grenzen im Endergebnis beachtet werden. Beispiel : type Note is range 1..5; subtype Ausreichende_Note is Note range 1..4; Parametrisierte Typen (Längenvarianten) Deklaration : type is Beispiele : type Variable_ZK(Max_Laenge: Integer) is record Laenge: Integer := 0; Info: String(1..Max_Laenge); end record ; type Matrix is array (Integer range <>, Integer range <>) of Real; type Square(Order: Positive) is record Mat: Matrix(1..Order, 1..Order); end record ; Objektvereinbarungen : M: Square := (4, (1..4 (1..4 0.0))); oder subtype Square_4 is Square(4); M: Square_4; Abgeleitete Datentypen Deklaration : type is new Ziel : Erzeugung neuer Datentypen aus alten ohne Verwendungskompatibilität trotz geerbter Operationen Möglichkeit der strukturellen und funktionellen Erweiterung des abgeleiteten Typs Erweiterungstypen (Anhangstypen) Charakterisierung : Erweiterbare Verbunde Erweiterung durch Hinzufügen weiterer Komponenten (auch 0 Komponenten) und passender Operationen Verwendung einer Typkennzeichnung (Marke, Anhang) für Laufzeitteste Typbeschreibung : tagged tagged null record ; Typabfrage : Klassenweiter Typ : Erweiterungstyp und alle durch Erweiterung daraus entstandenen Typen Bezeichnung : T ´Class T Erweiterungstyp T ´Class ist mit T und den daraus abgeleiteten erweiterten Typen kompatibel. Beispiel : with Calendar, People; package Alert_System is type Alert is tagged record Time_Of_Arrival: Calendar.Time; Message:Text; end record : procedure Display(A: in Alert); procedure Handle(A: in out Alert); procedure Log(A: in Alert); type Low_Alert is new Alert with null record ; type Medium_Alert is new Alert with record Action_Officer: People.Person; end record ; procedure Handle(MA: in out Medium_Alert); type High_Alert is new Medium_Alert with record Ring_Alarm_At: Calendar.Time; end record ; procedure Handle(HA: in out High_Alert); procedure Set_Alarm(HA: in High_Alert); end Alert_System; Klassenweiter Typ Alert ´Class: Alert Time_Of_Arrival Message Display, Handle, Log Low_Alert Medium_Alert Time_Of_Arrival Message Action_Officer Display, Handle , Log High_Alert Time_Of_Arrival Message Action_Officer Ring_Alarm_At Display, Handle , Log, Set_Alarm Dynamisches Dispatching : procedure Process_Alert(AC: in out Alert ´Class); begin Put_Line( ´´Processing Alert´´); Handle(AC); end Process_Alert; MA: Medium_Alert; HA: High_Alert; Process_Alert( MA ) ruft Handle(MA) auf. Process_Alert( HA ) ruft Handle(HA) auf. Namen Bezeichnen implizit oder explizit deklarierte Dinge sowie durch Zeigerwert bezeichnete Objekte oder Unterprogramme, Ergebnisse von Funktionsaufrufen oder Typkonvertierungen, Unterkomponenten und Schnitte von Objekten und Werten, geschützte Unterprogramme, einzelne Entries, Entry-Familien, Attribute aller vorherigen Dinge Indizierte Komponenten Beispiele : Page(10), Page ist ein 1-dimensionales Feld Next_Frame(L)(M, N) Next_Frame(L) ist ein Funktionsaufruf, der ein 2-dimensionales Feld liefert Schnitte (Ausschnitte, slices) Liefert ein 1-dimensionales Feld aus aufeinanderfolgenden Komponenten eines 1-dimensionalen Feldes Definition : Beispiele : Stars: String(1..120); Stars(1..0) leerer Schnitt Stars(1..15) Schnitt enthält erste 15 Zeichen aus Stars A 1-dimensionales Feld A(N..N) 1-elementiges 1-dimensionales Feld A(N) N. Komponente von A Page: array (Positive range <>) of Line; Page(L)(A..B) Schnitt aus der L. Zeile von Page Auswahlkomponenten Bezeichnung von Komponenten, Entries, Entry Familien, geschützten Unterprogrammen oder expandierten Namen Definition : Beispiele : Next_Car.Owner Min_Cell(H).Value, Min_Cell(H) ist ein Funktionsaufruf Key_Manager. ´´<´´ Operator eines Pakets Aggregate Kombinieren Werte zu zusammengesetzten Werten vom Feldtyp oder Verbundtyp Verbundaggregat : ( null record Folge von Komponentenassoziationen Komponentenassoziation: [ others Folge von Selektornamen getrennt durch | Art: positioniert, benannt, others Beispiele : (4, July, 1776) (Day 4, Month July, Year 1776) (Year (Value 1776, Month 0, Succ|Pred July, Day 4) new Cell ´(0, null , null )) Feldaggregat : Positionsfeldaggregat: ( others Beispiele : (7, 9, 5, 4, 8) ((1.1, 1.2, 1.3), (2.1, 2.2, 2.3)) E: Bit_Vektor(M..N) := ( others (5, 8, 4, 1, others 0) True); Benanntes Feldaggregat : ( Beispiele : (1..N (1..5 new Cell) (1..8 0.0)) (1 (1.1, 1.2, 1.3), 2 B: Table := (2|4|10 1, (2.1, 2.2, 2.3)) others 0) Attribute : Liefern Werte, die Eigenschaften bestimmter Daten darstellen. Ausdruck : Definiert die Berechnung oder das Aufsuchen eines Wertes. Aufbau : siehe Syntaxregeln Abarbeitungsreihenfolge : 1. 2. 3. Nach Klammerung Nach Prioritäten Bei gleicher Priorität von links nach rechts Beispiele : Real(M*N) Konvertierung (1..10 0) Feldaggregat Password(1..3) = ´´Bwv´´ Vergleich (Cold and Sunny) or Warm Operatoren : Operator Name ** abs not Exponentiation Absolutwert Negation Typen IxNa; GkxI N B Operator / * Name Multiplikation Division mod rem +/ + & Restbildung (periodisch) Restbildung (gespiegelt) Vorzeichen Addition Subtraktion Verkettung Typen NxN NxN; Fk und Gk mischbar IxI GxG N NxN NxN F1xF1 Operator = /= < > <= >= in not in and or xor Name Gleichheit Ungleichheit Kleiner Größer Kleiner-Gleich Größer-Gleich Element von nicht Element von Konjunktion Disjunktion exklusive Disjunktion Typen TxT TxT NxN; AxA; F1xF1 NxN; AxA NxN; AxA ExBe ExBe BxB BxB BxB Operator and then or else Name verkürzende Konjunktion verkürzende Konjunktion Prioritäten: 1 2 3 4 5 6 Typen BxB BxB Typen: I Integer Fk Festkomma B Boolean T beliebiger Typ F1 1-dim. Felder N Numerisch Gk Gleitkomma Be Bereichstyp A Aufzählungstyp Na natürliche Zahlen Bemerkungen zu den Operationen: and then , or else : Berechnung des linken Operanden und anschließend, wenn nötig des rechten in , not in : not ] in Definition von A mod B: - Hat Vorzeichen von B. - |A mod B| < |B| - Es existiert ein Integerwert N mit A = B * N + (A mod B) . Definition von A rem B: - Hat Vorzeichen von A. - |A rem B| < |B| - A = (A/B) * B + (A rem B) not für 1-dimensionale logische Felder: Anwendung auf jede Komponente not für modulare Typen: Liefert Differenz zwischen oberer Grenze des Basisbereichs und Wert des Operanden not , and , or , xor für ganze Zahlen: Anwendung der Operationen auf korrespondierende Bits der Operanden Beispiele : Today in Weekday N not in 1..10 17 and 3 = 1 (0010001 and 0000001) (1, 2, 3) < (1, 2, 3, 4) Next_Car.Owner /= null and then Next_Car.Owner.Age > 25 11 rem 5 = 1 -11 rem 5 = -1 11 rem -5 = 1 -11 rem -5 = -1 11 mod 5 = 1 -11 mod 5 = 4 11 mod -5 = -4 -11 mod -5 = -1 Konvertierungen (Wertkonvertierungen): Erlaubt für eng verwandte Typen: - Numerische Typen - Von einem gemeinsamen Typ abgeleitete Typen - Reihungstypen mit a) gleichem Komponententyp b) gleicher Dimension c) gleichem Basistyp und gleicher Anzahl Indexwerte bei korrespondie renden Indextypen Notation : Operandtyp und die Typbezeichnung liefert den Zieltyp . Beispiele : Real(2*J); subtype Dozen is Sequence(1..12); Ledger: array (1..100) of Integer; ...Dozen(Ledger(31..42))... Bemerkung : Es gibt auch implizite Konvertierungen, wie z.B. von einem universal-Typ eines Literals in einen erforderlichen spezifischen Typ. Diese Konvertierung kann nicht immer durch den Compiler eindeutig bestimmt werden Qualifizierungen : Beispiele : Color ´(Red); type Mask is (Fix, Dec, Exp, Signif); Print(Mask ´(Dec)); ...Dozen ´(1|3|5|7 2, others 0); Allokation : Bildet neues Objekt und liefert Zeigerwert darauf Notation: new new Beispiele : new Matrix ´(1..10 (1..20 0.0)); New Matrix(1..10, 1..20); Ausnahme : Ausnahme, ernsthafter Fehler; keine Programmvariante Ausnahmebehandlung : Standard : Programmstopp mit Angabe von Ausnahmeart und Ausnahmeort in Abhängigkeit vom Compiler Ausnahmebehandlung durch Programmierer Ausnahmearten : Vordefiniert : Constraint_Error, Program_Error, Storage_Error, Tasking_Error Ausnahmen in Bibliothekspaketen : z.B. End_Error, Name_Error Nutzerdefiniert Ausnahmedeklaration : Deklaration des Namens einer Ausnahme Notation: exception ; Ausnahmebehandler : Definition vor end nach betroffener Anweisungsfolge und exception Form: when [ begin - Block oder Körper einer Einheit exception when ...; when ...; end ; Auswahlparameter : konstantes Objekt des Typs Exception_Occurence; repräsentiert konkretes Auftreten einer Ausnahme Ausnahme : Name einer Ausnahme oder others (vertritt weitere, bisher nicht angeführte Ausnahmen) Beispiel : begin Open(File, In_File, ´´input.txt´´); exception when E: Name_Error Put( ´´Cannot open input file: ´´); Put_Line(Exception_Message(E)); raise ; end ; Erzeugung einer Ausnahme : Automatisch Durch raise-Anweisung (bei nutzerdefinierten Ausnahmen notwendig): - raise [ - raise (tritt nur in einem Ausnahme behandler auf) Behandelte Ausnahme wird ein Niveau höher erneut erzeugt. Bearbeitung einer Ausnahme : 1. Erzeugung einer Ausnahme Abarbeitung des Konstrukts wird 2. abgebrochen a) Konstrukt ist Körper einer Task Propagierung der Ausnahme keine b) Folgt ein passender Handler, erfolgt Weiterbehandlung durch ihn, wobei das Auftreten der Ausnahme zuvor dem Parameter übergeben wurde. c) Sonst: Weitergabe der Ausnahme ein Niveau höher Objektbasierte Softwareentwicklung: Basiert auf ADT Praktiziert in Ada 83 Zusätzlich Nutzung einer primitiven Vererbung über Erweiterung der Operationsmenge Objektorientierte Softwareentwicklung: Unterstützung der Variantenprogrammierung : Konstruktion neuer Abstraktionen aus vorhandenen durch Angabe der Unterschiede Unterstützung des klassenüberdeckenden Programmierens : einheitliche Behandlung von Klassen verwandter Abstraktionen Nutzung der Konzepte - verschachtelter Pakete - generischer Einheiten - der Erweiterungstypen - klassenweiter Typen - abstrakter Konstrukte Klasse : Alle direkt oder indirekt abgeleiteten Typen zusammen mit dem Basistyp Wert eines klassenweiten Typs: ( Konvertierung und klassenüberdeckende Programmierung Musterdefinition für objektorientierte Typen mit einfacher Vererbung with use package is type is tagged private ; type --oder new with private ; is access all private -- Details von end Dynamisches Dispatching : Anwendbar nur auf Unterprogramme eines Erweiterungstyps aus dem gleichen Paket Wirkungsweise : T ´Class klassenweiter Typ P Q Unterprogramm mit formalem Parameter F des Typs T ´Class durch P aufgerufenes Unter programm mit Parameter F Ts Ts aus T abgeleiteter Typ des aktuellen Parameters zu F Auswahl des spezifischen Q entsprechend Beispiel : siehe Paket Alert_System P sei Process_Alert Q sei Handle F sei AC vom Typ Alert ´Class Beim Aufruf von Process_Alert wird das Unterprogramm Handle aufgerufen, welches gemäß Typ des aktuellen Parameters zu AC ausgewählt wird. Klassenüberdeckende Operationen : Operand oder Resultat ist von klassenweitem Typ Anwendung auf jeden spezifischen Typ der Klasse bzw. jeden abgeleiteten klassenweiten Typ Typkonvertierung innerhalb von Klassen : Nur zur Wurzel hin erlaubt Beispiel : Konvertierung von Medium_Alert zu Alert, aber nicht umgekehrt Konvertierungen von der Wurzel zu den Blättern nur unter Verwendung von Erweiterungsaggregaten Beispiel : Alert zu Low_Alert LA vom Typ Low_Alert A vom Typ Alert LA := (A with null record ); Konvertierung eines klassenweiten Typs in einen spezifischen Typ Beispiel : AC vom klassenweiten Typ Alert_Class MA: Medium_Alert := Medium_Alert(AC); AC muss zur Laufzeit von einem Typ aus Medium_Alert ´Class sein. Dann wird es in den Typ Medium_Alert konvertiert. Konvertierung als Ansichtkonvertierung Beispiele : MA vom Typ Medium_Alert HA vom Typ High_Alert - Handle(Alert(MA)); Alert(MA) hat den gleichen Wert wie MA, aber die zusätzlichen Komponenten des Typs Medium_Alert gegenüber High_Alert sind nicht sichtbar. - MA := Medium_Alert(HA); Zum Typ Medium_Alert passende Komponenten von HA werden kopiert. Konvertierungen auf der linken Seite von Zuweisungen Beispiel : AC: Alert ´Class :=...; ... Medium_Alert(AC) := MA; Ist AC während der Laufzeit von einem Typ aus Medium_Alert ´Class, dann werden die Komponenten von MA auf die passenden Komponenten von AC kopiert. Abstrakte Typen und Unterprogramme : Können zu Festlegung von Eigenschaften ohne konkrete Objekte genutzt werden Abstrakte Unterprogramme führen zum Dispatching gemäß Typkonkretisierung Abstrakte Unterprogramme müssen bei Ableitung von konkreten Typen aus abstrakten durch konkrete Unterprogramme überschrieben werden. Beispiele : Abstrakte Menge package Sets is subtype Element_Type is Natural; type Set is abstract tagged null record ; function Empty return Set is abstract ; function Union (Left, Right: Set) return Set is abstract ; function Intersection (Left, Right: Set) return Set is abstract ; function Unit_Set (Element: Element_Type) return Set is abstract ; procedure Take (Element: out Element_Type; From: in out Set) is abstract ; end Sets; Geometriepaket package Geo is type Geometrisches_Objekt is abstract tagged private ; type Pixel_Koordinaten is record X, Y: Integer; end record ; type Bildschirmfarbe is range 0..15 ; procedure Verlagere (Was: in out Geometrisches_Objekt; Wohin: in Pixel_Koordinaten); procedure Zeige (Was: in Geometrisches_Objekt) is abstract ; private type Geometrisches_Objekt is tagged record Farbe: Bildschirmfarbe; Bezugspunkt: Pixel_Koordinaten; end Geo; end record ; -- Paket Geo.Flaechenobjekte package Geo.Flaechenobjekte is type Flaechenobjekt is abstract new Geometrisches_Objekt with private ; private type Flaechenobjekt is abstract new Geometrisches_Objekt with record Gefuellt: Boolean; end record ; end Geo_Flaechenobjekte; -- Paket Geo.Flaechenobjekte.Kreise package Geo.Flaechenobjekte.Kreise is type Kreis is abstract new Flaechenobjekt with private ; private type Kreis is abstract new Flaechenobjekt with record Radius: Float; end record ; end Geo.Flaechenobjekte.Kreise; -- Geo.Flaechenobjekte.Rechtecke package Geo.Flaechenobjekte.Rechtecke is type Rechteck is abstract new Flaechenobjekt with private ; private type Rechteck is abstract new Flaechenobjekt with record Eckpunkt_2: Pixel_Koordinaten; end record ; end Geo.Flaechenobjekte.Rechtecke; Paketstruktur Kreise Geo Flaechenobjekte Rechtecke Typstruktur Geometrisches_Objekt Flaechenobjekt Farbe Bezugspunkt Farbe Bezugspunkt Gefuellt Kreis Farbe Bezugspunkt Gefuellt Radius Rechteck Farbe Bezugspunkt Gefuellt Eckpunkt_2 -- Ausgabe einer Reihung geometrischer Objekte with Geo; package Geo_Reihungen is type Geo_Zeiger is access Geo.Geometrisches_Objekt´Class; type Geo_Reihung is array (Positive range <>) of Geo_Zeiger; procedure Zeige (Was: in Geo_Reihung); end Geo_Reihungen; with Geo; use Geo; package body Geo_Reihungen is procedure Zeige (Was: in Geo_Reihung) is begin for I in Was´Range loop Zeige (Was (I). all ); end loop ; end Zeige; end Geo_Reihungen; In Ada gibt es keine Mehrfachverarbeitung. Sie kann aber in vielen Fällen unter Nutzung einer der folgenden Techniken gut realisiert werden: 1. 2. 3. Kombination zweier Klassen Mischung einer generischen Einheit mit einem abstrakten Typ über einen formalen Parameter Ableitung eines Typs von mehreren Eltern durch Parametrisierung eines Verbunds mit einem anderen Beispiele : Bounded_Stack[T] aus Stack[T] und Array[T] package Bounded is type Boundd_Stack(Size: Natural := 0) is private ; procedure Push(S: in out Bounded_Stack; Element: T); procedure Pop(S: in out Bounded_Stack); function Top(S: Bounded_Stack) return T; private type T_Array is array (Integer range <>) of T; type Bounded_Stack(Size: Natural := 0) is record Data: T_Array(1..Size) ; end record ; end Bounded; Ableitung eines Typs T aus einem abstrakten Erweiterungstyp S innerhalb eines generischen Pakets, wobei S Typparameter ist generic type S is abstract tagged private ; package P is type T is abstract new S with private ; -- Operationen von T ... private type T is abstract new S with record - zusätzliche Komponenten end record ; end P;IV Datentypen und Deklarationen Typkonzept
Typklassen
Typklassen
(Fortsetzung)
Elementare Typen Skalare Typen
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung) Aufzählungstypen
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung) Integertypen
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung) Reelle Typen
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung)
Elementare Typen (Fortsetzung) Zeigertypen
Zusammengesetzte Typen Felder (Array-Typen, Reihungen)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Felder (Fortsetzung)
Zusammengesetzte Typen Verbundtypen
Zusammengesetzte Typen Verbundtypen (Fortsetzung)
Zusammengesetzte Typen Verbundtypen (Fortsetzung)
Zusammengesetzte Typen Verbundtypen (Fortsetzung)
Zusammengesetzte Typen Verbundtypen (Fortsetzung)
Zusammengesetzte Typen Verbundtypen (Fortsetzung)
Zusammengesetzte Typen Verbundtypen (Fortsetzung)
IV Datentypen und Deklarationen Typdeklarationen
V Ausdrücke Grundbestandteile
V Ausdrücke Ausdrücke
VI Ausnahmebehandlung
VII Objektorientierte Programmierung
Anwendung des Pakets Geo
Mehrfachvererbung