imported>L47: /* Operatorüberladung */ Fehlende Satzzeichen ergänzt.

2021-10-20T06:15:51Z

Operatorüberladung: Fehlende Satzzeichen ergänzt.

Neue Seite

{{Dieser Artikel|erläutert das Konzept des Überladens bei Programmiersprachen. Zu anderen Bedeutungen siehe [[Überladung]].}}
'''Überladen''' (von {{enS|''overloading''}}) bedeutet in der Softwareentwicklung das bewusste Etablieren von [[Polymorphie (Programmierung)|Polymorphien]], sodass ein und dasselbe Sprachelement – [[Operator (Mathematik)|Operatoren]], [[Konstruktoren und Destruktoren|Konstruktoren]], [[Literal]]e und dergleichen – unterschiedliche, aus dem Kontext hervorgehende Bedeutungen annehmen können. Das Überladen wird, da es sich um einen rein syntaktischen Mechanismus handelt, nach [[Christopher Strachey|Strachey]] als ''Ad-hoc-[[Polymorphie (Programmierung)|Polymorphie]]'' betrachtet.

Nicht alle [[Programmiersprache]]n ermöglichen das Überladen, als Verfahren ist es insbesondere bei objektorientierten Programmiersprachen anzutreffen.

== Erläuterung an einem Beispiel ==
In vielen Programmiersprachen steht der Operator <code>+</code> für verschiedene, durchaus unterschiedliche, Operationen:

1 + 2
"abc" + "def"

Im ersten Fall ist das erwartbare Ergebnis "3", also eine Integer-[[Addition]], im zweiten "abcdef", also eine [[Wort (Theoretische Informatik)#Konkatenation|String-Konkatenation]]. Dies sind im Grunde zwei sehr unterschiedliche Operationen. [[Compiler]] oder [[Interpreter]] von Sprachen, die eine solche sogenannte [[Polymorphie (Programmierung)|Polymorphie]] erlauben, tun dies, indem sie die anzuwendende Methode (Addition oder Konkatenation) aufgrund des Datentyps der beteiligten Operanden auswählen.

Von '''Überladung''' spricht man nun, wenn eine solche Polymorphie nicht nur, wie im Falle des Beispiels, vorgefertigt in einer Sprache vorhanden ist, sondern darüber hinaus auch durch Sprachkonstrukte weitere solcher Polymorphien geschaffen werden können. Im obigen Beispiel etwa könnte die Sprache die Möglichkeit bieten, durch Programmtext eine zusätzliche Bedeutung des <code>+</code>-Operators für andere Datentypen (etwa Arrays) zu etablieren. (Dies wäre dann ein Beispiel für [[#Operatorüberladung|Operatorüberladung]].)

== Methodenüberladung ==
Methodenüberladung liegt vor, wenn mehrere [[Methode (Programmierung)|Methoden]] denselben Namen haben, sie aber verschiedene Parameter (engl. ''argument'') erwarten. Welche Methode genau aufgerufen wird, wird dann bei jedem Aufruf anhand der Parameter und ihrer Datentypen automatisch vom Compiler bestimmt. Ein typisches Beispiel ist eine Methode, die sowohl Texte ([[Zeichenkette|Strings]]) als auch ganze Zahlen ([[Integer (Datentyp)|Integer]]) auf dem Bildschirm ausgeben können soll. Beispiel aus [[Pascal (Programmiersprache)|Pascal]]:

<syntaxhighlight lang="pascal">
procedure GibAus(text: String); overload;
begin
writeln(text); // übergebenen Parameter ausgeben
end;

procedure GibAus(zahl: Integer); overload;
var
zahlAlsText: String;
begin
zahlAlsText := IntToStr(zahl); // übergebene Zahl in einen Text umwandeln
writeln(zahlAlsText); // ausgeben
end;

begin
GibAus('Hallo Welt!'); // gibt den Text "Hallo Welt!" aus
GibAus(4711); // gibt die Zahl 4711 aus
end;
</syntaxhighlight>

Im Falle von [[Funktion (Programmierung)|Funktionen]] ist in manchen Sprachen auch die Überladung anhand des ''Ergebnis''-Typs möglich.

Nachteil ist ein Verlust an Übersichtlichkeit und dass Probleme auftreten können, wenn nachträglich weitere Überladungen hinzugefügt werden (vgl. das unten verlinkte Wikibook).

=== Abgrenzung ===
==== Standardwerte ====
Keine Methodenüberladung im eigentlichen Sinne ist der ''Standardwert'' (engl. ''default argument''), welcher ebenfalls dazu führt, dass eine – allerdings dieselbe – Methode mit unterschiedlichen, nämlich unterschiedlich vielen, Parametern aufgerufen werden kann. Wird ein Parameter ausgelassen, wird hierbei stattdessen der Standardwert übergeben:

<syntaxhighlight lang="pascal">
procedure GibAus(text: string = 'kein Parameter übergeben');
begin
writeln(text); // übergebenen Parameter ausgeben
end;

begin
GibAus('Hallo Welt!'); // gibt "Hallo Welt!" aus
GibAus(); // gibt den Standardwert "kein Parameter übergeben" aus
end;
</syntaxhighlight>

Methoden mit Standardwert können problemlos in überladene Methoden überführt werden. Obiger Quelltext ist funktional mit folgendem identisch:

<syntaxhighlight lang="pascal">
procedure GibAus(text: String); overload;
begin
writeln(text); // übergebenen Parameter ausgeben
end;

procedure GibAus(); overload;
begin
GibAus('kein Parameter übergeben'); // fehlenden Parameter ergänzen
end;

begin
GibAus('Hallo Welt!'); // gibt "Hallo Welt!" aus
GibAus(); // gibt den Standardwert "kein Parameter übergeben" aus
end;
</syntaxhighlight>

Dies ist hilfreich in Sprachen, die Standardwerte nicht unterstützen, beispielsweise Java.

==== Implizite Typumwandlungen ====
Ebenfalls von der Methodenüberladung zu unterscheiden sind implizite [[Typumwandlung]]en. In vielen Programmiersprachen lässt sich eine einzelne Methoden, die einen [[Gleitkommazahl|Gleitkommawert]] (Real) als [[Wertparameter]] erwartet, auch mit einer ganzen Zahl (Integer) aufrufen. Eine implizite Typumwandlung ist bei einem [[Referenzparameter]] nicht möglich, da [[Referenzparameter#Formale und tatsächliche Parameter|formale und tatsächliche Parameter]] übereinstimmen müssen:

<syntaxhighlight lang="pascal">
function QuadriereWertparameter(basis: Real): Real;
begin
result := basis * basis; // Ergebnis als Funktionswert zurückgeben
end;

procedure QuadriereReferenzparameter(var basis: Real);
begin
basis := basis * basis; // Ergebnis dorthin schreiben, wo der Parameter herkam
end;

var
zahl: Integer;
begin
zahl := 4711;
QuadriereWertparameter(zahl); // implizite Typumwandlung (Ergebnis der Funktion wird verworfen)
QuadriereReferenzparameter(zahl); // Compilerfehler, denn die aufgerufene Methode könnte keine Kommazahl zurückgeben, obwohl eine Kommazahl als Referenzparameter deklariert wurde
end;
</syntaxhighlight>

Würde man im obigen Quelltext die folgende überladene Methode (und die <code>overload</code>-Direktive bei der vorhandenen Methode) ergänzen, wäre das Programm kompilierbar:

<syntaxhighlight lang="pascal">procedure QuadriereReferenzparameter(var basis: Integer); overload;
begin
basis := basis * basis;
end;
</syntaxhighlight>

== Operatorüberladung ==
Seit jeher unterschieden die meisten Programmiersprachen, der [[Mathematik|mathematischen]] Tradition folgend, nicht zwischen den [[Operator (Mathematik)|Operatorsymbolen]] (<code>+</code>, <code>-</code>, …) für Ganzzahl- ([[Integer (Datentyp)|Integer]]‑) und [[Gleitkommazahl|Gleitpunktarithmetik]] (real, float). Zur bruchlosen Erweiterung einer Sprache um benutzerdefinierte Typen ist es hilfreich, die Operatorsymbole auch für benutzerdefinierte Typen überladen zu können.

Ein Beispiel für das Überladen des Operators <code>+</code> in [[C++]]:

<syntaxhighlight lang="cpp">
struct komplexe_zahl {
float real = 0;
float imag = 0;
};

komplexe_zahl operator+(komplexe_zahl links, komplexe_zahl rechts) {
return komplexe_zahl {links.real + rechts.real, links.imag + rechts.imag};
}

int main() {
komplexe_zahl z1 {5.0f, 3.14159f};
komplexe_zahl z2 {0.0f, -3.14159f};
komplexe_zahl z3 = z1 + z2; // z3.m_real = 5 und z3.m_imag = 0
}
</syntaxhighlight>

In C++ lassen sich fast alle vorhandenen Operatoren überladen, was in den meisten Fällen sowohl über freistehende Funktionen (wie hier) als auch über Methoden erfolgen kann.

Ziel der Operatorüberladung ist die leichte [[Lesbarkeit]] des Quelltext, wobei stets beachtet werden sollte, inwieweit diese durch überladene Operatoren verbessert oder verschlechtert wird: Während beispielsweise <code>(a + b) * c</code> klar besser zu lesen ist als <code>mal(plus(a, b), c)</code> ist dies bei weitem nicht immer der Fall, insbesondere wenn die konkrete Überladung nicht weithin bekannten Konventionen folgt.

Zuletzt ist anzumerken, dass es sich bei Operatorenüberladung nur um [[syntaktischer Zucker|syntaktischen Zucker handelt]] und es in aller Regel genau so möglich wäre die gewünschte Funktionalität auch durch normale Funktionen bzw. Methoden zu implementieren.

== Siehe auch ==
* [[Polymorphie (Programmierung)]]
* [[Kovarianz und Kontravarianz|Kovarianz (Informatik)]]

== Weblinks ==
*[[b:Strukturierte Programmierung#Überladung|Überladung]], Wikibook ''Strukturierte Programmierung''

{{Normdaten|TYP=s|GND=4531051-8}}

{{SORTIERUNG:Uberladen}}
[[Kategorie:Programmierkonzept]]

Überladen - Versionsgeschichte

imported>L47: /* Operatorüberladung */ Fehlende Satzzeichen ergänzt.