Ada Tour - Dokumentation

zurück

vor

7.9 Parameterübergabe Operatoren / Überladung

In Ada sind Operatoren Funktionen. Dieses ist besonders leicht zu erkennen, wenn Operatoren in Präfix-Schreibweise verwendet werden.

Jede Operation kann nicht nur in der bekannten Infix-Notation, sondern auch in der Präfix-Notation ausgedrückt werden (wichtig: Anführungszeichen).

Beispiele:

Ergebnis:= A*B --infix
Ergebnis:= "*"(A,B) --präfix

Operatoren können überladen werden. Mit dem Überladen (overloading) können - Funktionen für neue Parameter-/ Ergebnisprofile geschaffen werden oder - Operatoren mit einer neuen Funktionalität überladen (deutlicher: verdeckt) werden.

Überladung ist ein Teil der objektorientierten Programmierung (OOP). Unter Überladen von Operatoren wird die Mehrfachverwendung eines Operators verstanden, z. B. "+" für Integer- und Float-Addition.

Auseinandergehalten werden überladene Operatoren vom Übersetzer anhand ihres Parameter- und Ergebnisprofils. Jeder der vordefinierten Operatoren ist durch den Sprachstandard bereits mehrfach überladen. Zusätzlich können weitere Operatorüberladungen programmiert werden. Alle vordefinierten Operatoren können überladen werden:

and, or, xor               (logical_operator <BNF>)
=, /=, <, <=, >, >=    (relational_operator <BNF>)
+, - ,&                        (binary_adding_operator <BNF>)
+, -                            (unary_adding_operator <BNF>)
*, /, mod, rem,          (multiplying_operator <BNF>)
**, abs, not              (highest_precedence_operator <BNF>)

Von einem neuen Parameter-/Ergebnisprofil spricht man dann, wenn sich eine Funktion in mindestens einem der folgenden Punkte von den vordefinierten Funktionen unterscheidet:

Anzahl der Parameter,
Typ eines Parameters,
Typ des Rückgabewertes.

Beispiel:

function "*" (Links, Rechts: in Komplexe_Zahl) return Komplexe_Zahl;

Hier wird eine Multiplikationsfunktion für einen eigendefinierten Typ Komplexe_Zahl definiert. Der Multiplikationsoperator ist überladen, weil das angegebene Parameter-/Ergebnisprofil sich von den Parameter-/Ergebnisprofilen der vordefinierten Multiplikationsoperatoren unterscheidet.

Sollen Operatoren verdeckt werden, so müssen die Anzahl der Parameter sowie ihre Benennung beibehalten werden.

Beispiel:

function "<" (Left, Right: in String) return Boolean is
begin
return Left'Length < Right'Length;
end "<";

In diesem Beispiel verdeckt die neue Funktion die durch den Sprachstandard vordefinierte Funktion "<" für Zeichenketten. Wenn durch Überladen eine andere Funktion verdeckt werden soll, wird das Parameter-/Ergebnisprofil der alten zu verdeckenden Funktion übernommen. D. h. die Parametertypen werden beibehalten. Bei positioneller Zuordnung der Parameter bei Operatoren interessieren die Namen der formalen Parameter in der Regel nicht.

Am Funktionsrumpf der neuen Funktion läßt sich das Prinzip des Verdeckens verdeutlichen. Die durch den Sprachstandard vordefinierte Funktion vergleicht Zeichenketten nach lexikographischer Ordnung. Durch das Verdecken wird erreicht, daß Zeichenketten nun nach ihrer Länge verglichen werden.

Es ist keinesfalls so, daß das Verdecken die alte Funktion unerreichbar macht. Die alte Funktion kann sichtbar gemacht werden, indem der erweiterte Name der Funktion angegeben und die Präfix-Schreibweise verwendet wird:

Ergebnis := Standard."<" (Left => Zeichenkette_A, Right => Zeichenkette_B);

Beide Funktionen können somit verwendet werden. Der Aufruf der neuen Funktion kann in Infix-Schreibweise erfolgen:
Ergebnis := Zeichenkette_A < Zeichenkette_B;

Beide Funktionsaufrufe sind möglich, liefern jedoch ein unterschiedliches Ergebnis. Wenn folgende Werte

Zeichenkette_A : String := "Elefant";
Zeichenkette_B : String := "Maus";

angenommen werden, dann ist im 1. Beispiel die Zeichenkette "Elefant" länger als die Zeichenkette "Maus", folglich ist "Elefant" > "Maus". Im 2. Beispiel wird nach der lexikographischen Ordnung verglichen. Hier ist "Elefant" < "Maus".

Die Aspekte der Überladung von Operatoren gelten ebenso für alle Funktionen und Prozeduren, d. h. alle Unterprogramme können überladen werden.

In vordefinierten Ada-Paketen lassen sich Beispiele für zahlreiche Überladungen finden. Auf den ersten Blick scheint dieses Konzept verwirrend zu sein, wenn verschiedene Unterprogramme den gleichen Unterprogrammnamen haben. Durch gleiche Namen für Unterprogramme mit gleicher Intention erhöht sich jedoch die Verständlichkeit.

with Ada.IO_Exceptions;

package Ada.Text_IO is
   -- ...
   -- String Input-Output

   procedure Get(File : in File_Type; Item : out String);
   procedure Get(Item : out String);

   procedure Put(File : in File_Type; Item : in String);
   procedure Put(Item : in String);

   procedure Get_Line(File : in File_Type;
                      Item : out String;
                      Last : out Natural);
   procedure Get_Line(Item : out String; Last : out Natural);

   procedure Put_Line(File : in File_Type; Item : in String);
   procedure Put_Line(Item : in String);
   -- ...
end Ada.Text_IO;

zurück

vor

Index

nach oben