Überladen von Funktionen

Im Gegensatz zu C und einigen anderen Sprachen sind in C++ die Argumenttypen zusätzlich zum Funktionsnamen relevant bei der Auswahl der aufzurufenden Funktion. Es ist möglich, eine print-Funktion für int zu haben, eine für double und eine weitere für struct Date {...}. Die Mehrfachverwendung des Funktionsnamens erlaubt, diesen von Typinformation freizuhalten und sich auf die Funktion zu beschränken. Als C-Gegenbeispiel können hier sprintf und fprintf dienen, in denen f und s den Typ des ersten Argumentes angeben. Diese Häßlichkeit (die darüberhinaus noch zu Fehlern führen kann, wenn beispielsweise der FILE * einmal durch char * ersetzt wird) wird in C++ vermieden; der Compiler wählt automatisch die richtige Funktion aus.

Man kann sich vorstellen, daß der Compiler dafür sorgt, daß gewissermaßen programmintern komplexere Namen für Funktionen verwendet werden, die neben dem Funktionsnamem auch noch die Argumente enthalten.

  void swap(int &a, int &b){   // internal name e.g. swap_int_int
    int tmp = a;
    a = b; b = tmp; 
  }

  void swap(double &a, double &b){     // swap_double_double
    double tmp = a;
    a = b; b = tmp; 
  }

  void f(){
    double a, b;
    int    i, j;
    // ...
    swap(a, b);  // double version              
    swap(i, j);  // int    version 
  }

Um zu verhindern, daß diese internen Namen auch für Funktionen erzeugt werden, die aus C-Bibliotheken geladen werden, müssen diese für den Compiler sichtbar als extern "C" deklariert werden.

  extern "C" double sqrt(double);

Dieser Mechanismus erlaubt dem Compiler sowohl das Erzeugen der richtigen Namen als auch die Berücksichtigung anderer Eigenarten der Sprache, deren Prozeduren der Linker an das Programm binden soll. Bei einem Funktionsaufruf kann z.B. die Reihenfolge, in der Parameter auf dem Stapel abgelegt werden eine andere als die in C++ sein.

Durch Überladen läßt sich ein ähnlicher Effekt erzielen wie mit Defaultargumenten, nämlich, daß nachträglich weitere Versionen der ``gleichen'' Funktion mit erweiterten Argumentlisten bereitgestellt werden können. Nachteil des Überladens zu diesem Zweck ist, daß dabei der Programmcode dupliziert wird, was zu größeren Programmen führt und größere Disziplin bei der Unterhaltung des verdoppelten Codes erfordert (Fehler (bugs) müssen in beiden Versionen entfernt werden).

Falls @ für einen eingebauten Operator steht, so erlaubt C++ auch, diesen als operator@() anzusprechen. Der Ausdruck 3 * z + 5 könnte also auch, weniger intuitiv, geschrieben werden als operator+(operator*(3,z),5).

In dieser Syntax lassen sich Operatoren genau wie Funktionen überladen. Dies kann dazu dienen, eine natürliche Syntax für benutzerdefinerte Typen wie z.B. Matrizen oder komplexe Zahlen einzuführen.