Überladung von Namen
Etwas Aufrufbares hat normalerweise eine bestimmten Anzahl von Parametern mit ganz bestimmten Datentypen. Normalerweise muß es mit ebensovielen Argumenten von verträglichen Datentypen aufgerufen werden.
Wenn etwas Aufrufbares durch einen Namen identifiziert wird, dann gehört zu dem Namen also eine bestimmte Form des Aufrufs, die durch Anzahl und Typ der Parameter bestimmt ist. Ein anderer Name kann wieder in anderer Weise (mit anderer Zahl von Argumenten anderen Typs) aufgerufen werden.
In einigen Programmiersprachen kann derselbe Name jedoch an mehrere verschiedene Formen des Aufrufs gebunden sein.
Das kann verwendet werden, um ein allgemeines Konzept durch einen einzigen Namen zu kennzeichnen, für das aber verschiedene Formen von Aufrufen möglich sein sollen. Beispielsweise ist „das Maximum von bestimmten Zahlen“ ein solches allgemeines Konzept, das in den verschiedensten Varianten als Abbildung vorkommen kann: Eine Abbildung könnte das Maximum zweier Ganzzahlen berechnen, eine andere Abbildung das Maximum zweier Gleitkommazahlen, eine dritte Abbildung das Maximum von drei Ganzzahlen.
Es gibt formale Sprachen, in denen pro Name nur ein Aufruftyp festgelegt werden kann. In der Programmiersprache C wird beispielsweise so verfahren. Dort gibt es drei verschiedene Namen für die Standardabbildungen zur Berechnung des Kosinuses, je nachdem ob dieser ein Parameter vom Typ "float", vom Typ "double" oder vom Typ "long double" hat. (Dies sind drei Gleitkommazahlentypen unterschiedlicher Genauigkeit.) Da die Aufruftypen sich unterscheiden, müssen sich in C auch die Namen unterscheiden und so werden diese Standardabbildungen dort mit dem Namen "cosf", dem Namen "cos", bzw. dem Namen "cosl" bezeichnet.
cos, cosf und cosl in C [Synopse]#include <math.h>
float cosf( float );
double cos( double );
long double cosl( long double );
Da die Abbildungen jedoch konzeptuell alle das gleiche machen, nämlich den Kosinus ihres Arguments berechnen, nur eben für verschiedene Datentypen, kann es als übersichtlicher empfunden werden, wenn sie alle den gleichen Namen erhielten. Das ist beispielsweise in C++ möglich, wo verschiedene Kosinusabbildungen den gleichen Namen haben können, wenn sie anhand ihrer Parameter hinreichend unterschieden werden können.
cos in C++ [Synopse]#include <cmath>
float std::cos( float );
double std::cos( double );
long double std::cos( long double );
Der Programmierer muß sich also in C++ nur noch einen Namen "std::cos" merken und kann diesen für verschiedene Aufruftypen benutzen. Diese Situation kann man auch so beschreiben, daß verschiedenes Aufrufbares sich denselben Namen teilt. Man spricht dann auch von einer Überladung dieses Namens. (Stattdessen könnte man aber auch sagen, daß etwas Aufrufbares [das durch seinen Namen "std::cos" bestimmt ist] in verschiedener Weise aufgerufen werden kann.)
Das Wort „Überladung“ kann man dabei so verstehen: Ein Bezeichner kann mit einer Bedeutung „geladen“ werden. Wenn ein Bezeichner über eine einzige Bedeutung hinausgehend mit mehreren verschiedenen Bedeutungen geladen wird, dann ist er sozusagen mit Bedeutungen überladen.
Bei der Übersetzung eines C++ -Programmes mit einem Aufruf eines überladenen Namens wird das Aufrufbare ausgewählt, das mit der Anzahl und den Typen der verwendeten Argumente am besten verträglich ist. (Die Details dieses Auswahlverfahrens sollen hier nicht behandelt werden.) Der Aufruf "std::cos( 2. )" hat ein Argument vom Typ "double", daher wird in diesem Fall die Funktion "std::cos" mit der Aufrufform "double std::cos( double );" aufgerufen, weil dessen Parameter vom Typ "double" am besten zu dem Argument "2." vom Typ "double" paßt.
Wenn es nur darum ginge, eine Funktion mit Argumenten verschiedenen Typs aufrufen zu können, dann würde oft die Typtoleranz von Parametern einer einzigen Funktion ohne Überladung ausreichen. Doch die Information über den Typ des verwendeten Arguments ginge dann verloren, weil der Argumenttyp in den Parametertyp gewandelt wird. Ein Vorteil der Verwendung eines überladenen Funktionsnamens gegenüber einer Funktion, die Argumente verschiedener Typen akzeptiert ist es, daß die Information über den Datentyp erhalten werden kann. Wird die oben als Beispiel genannte Funktion "std::cos" mit einem Argument vom Typ "double" aufgerufen, so ist das Ergebnis wieder vom Typ "double", wird sie mit einem Argument vom Typ "float" aufgerufen, so ist das Ergebnis wieder vom Typ "float". Gäbe es nur die double-Variante, so könnte man diese zwar auch mit einem Argument vom Typ "float" aufrufen, das dann automatisch in den Parametertyp "double" gewandelt werden würde, doch das Ergebnis wäre dann auch vom Typ "double" und so wäre die Information über den Argumenttyp "float" verloren gegangen.