Überladen von Funktionen

In C++ ist es möglich, mehrere Funktionen mit ein und demselben Namen zu versehen. Dies heißt Überladen von Funktionen.

Die Auswahl, welche der gleichnamigen Funktionen in einem konkreten Fall gemeint ist, geht für den Compiler dann (hoffentlich) aus dem Zusammenhang hervor: nämlich aus der Parameterliste des Aufrufs (der Typ des Rückgabewerts wird dagegen nicht zur Unterscheidung herangezogen, auch wenn die überladenen Funktionen unterschiedliche Typen zurückgeben können!).

Hinter einem bestimmten Funktionsnamen können sich also mehrere verschiedene Funktionen verstecken (Polymorphie).

Beispiel:

// Time-stamp: "(15.11.01 16:10) ueberlf.cpp [Klaus Wachtler (aw38)]"
// 
// zeigt das Ueberladen von Funktionen.

#include <iostream> 
#include <cstring>
#include <cstdlib>

using namespace std;

int summe( int s1 )
{
  cout << "summe( int " << s1 << " ) = ";
  return s1;
}

int summe( int s1, int s2 )
{
  cout << "summe( int " << s1 << ", int " << s2 << " ) = ";
  return s1 + s2;
}

double summe( double s1 )
{
  cout << "summe( double " << s1 << " ) = ";
  return s1;
}

double summe( double s1, double s2 )
{
  cout << "summe( double " << s1 << ", double " << s2 << " ) = ";
  return s1 + s2;
}

double summe( double s1, int s2 )
{
  cout << "summe( double " << s1 << ", int " << s2 << " ) = ";
  return s1 + s2;
}

char *summe( char *s1, const char *s2 )
{
  cout << "summe( char * \"" << s1 
       << "\", const char * \"" << s2 << "\" ) = ";
  return strcat( s1, s2 );
}

char *summe( char *s1, int n )
{
  char  *p = (char *)malloc( strlen(s1) + 1 );
  int    i;

  cout << "summe( char * \"" << s1 
       << "\", int " << n << " ) = ";

  strcpy( p, s1 );
  for( i=0, *s1 = '\0'; i<n; i++ )
    {
      strcat( s1, p );
    }

  return s1;
}

int main( int nargs, char *args[] )
{
  char
    string1[100] = "So so!",
    string2[100] = " Aber, Aber!";

  cout << summe( 10 ) << endl;
  cout << summe( 1.34 ) << endl;
  cout << summe( 10, 20 ) << endl;
  cout << summe( 1.34, 20 ) << endl;
  cout << summe( 3.1412856, 2.71828 ) << endl;
  cout << summe( string1, " Ja ja!" ) << endl;
  cout << summe( string2, 3 ) << endl;
}

An der Ausgabe sieht man ganz schön, daß -trotz des wiederholten Funktionsnamens- jeder Funktionsaufruf zu einer anderen Funktion gehört. Der Compiler wählt unter den überladenen Funktionen diejenige aus, deren Parameterliste ,,am besten`` zu den Parametern eines Aufrufs paßt:

summe( int 10 ) = 10
summe( double 1.34 ) = 1.34
summe( int 10, int 20 ) = 30
summe( double 1.34, int 20 ) = 21.34
summe( double 3.14129, double 2.71828 ) = 5.85957
summe( char * "So so!", const char * " Ja ja!" ) = So so! Ja ja!
summe( char * " Aber, Aber!", int 3 ) =  Aber, Aber! Aber, Aber! Aber, Aber!

Obwohl C++ das nicht erzwingen kann, ist es natürlich sinnvoll, nur Funktionen eines Namens zu überladen, die auch sinngemäß ähnlich mit ihren Parametern reagieren. So kann es durchaus sinnvoll sein, in der Funktion

char *summe( char *s1, const char *s2 )

zwei Strings aneinanderzuhängen und diese Operation mit dem Namen summe zu garnieren. Aber in

char *summe( char *s1, int n )

wird ein String mehrfach hintereinandergehängt. Dieser Funktion den Namen summe zu geben, ist ziemlich schwachsinnig und fördert nicht unbedingt die Lesbarkeit eines Programms.