Die Überladung von Funktionsnamen in C++

Wenn zwei oder mehr Definitionen für einen Bezeichner im selben Bereich gelten, dann sagt man auch, diese Bezeichner sei überladen. Ein überladener Funktionsname gehört also zu mehreren, verschiedenen Funktionen. Wenn ein überladener Funktionsname auf Argumente angewendet wird, dann wird der Typ der Argumente mit dem Typ der Parameter der Funktionen mit diesem Namen verglichen, um die anzuwendende Funktion zu bestimmen.

Mehrere Funktionen, die eines Gültigkeitsbereichs den gleichen Namen miteinander teilen, müssen sich allerdings in der Zahl oder wenigstens den Typen ihrer Parameter ausreichend unterscheiden.

In dem folgenden Beispiel werden zwei Funktionen mit dem Bezeichner "print" definiert, deren Argument vom Typ "int" bzw. vom Typ "double" ist.

ueberladung.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
void print(){}
void print( int const wert )
{ std::cout << "int"s << wert; }
void print( double const wert )
{ std::cout << "double"s << wert; }
int main()
{ int    const i { 2         };
  double const d { 3.1415926 };
  print(); print( i ); print( d ); 
  ::std::cout << "\n"s; }

Ohne die Möglichkeit der Funktionsnamensüberladung, müßte man den beiden Funktionen verschiedene Namen geben. Die Namen wären so aber mühevoller zu erlernen und ihre Verschiedenheit wäre unpassend, wenn sie die praktisch gleiche Operation darstellen, nur für unterschiedliche Datentypen. Die Funktionsnamensüberladung erlaubt hier eine viel natürlichere Formulierung unter Beibehaltung der Typstrenge, durch die Kontrolle der Verwendung von Ausdrücken anhand ihres Datentyps bei der maschinellen Analyse eines C++ -Programms.

Weglassen des Parameternamens

Wenn der Parameter im Rumpfe einer Funktionsdefinition gar nicht verwendet wird, dann darf der Parametername in der Parameterdeklaration auch entfallen.

ueberladung.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
void print(){}
void print( int const )
{ std::cout << "int"s; }
void print( double const )
{ std::cout << "double"s; }
int main()
{ int    const i { 2         };
  double const d { 3.1415926 };
  print(); print( i ); print( d ); 
  ::std::cout << "\n"s; }

Übungsaufgaben

Definieren Sie zwei Wirkfunktionen "printtype" jeweils für ein Argument vom Datentyp "int" und vom Datentyp "double". Jede Wirkfunktion soll den Namen des Datentyps ihres Parameters ausgeben.

ueberladung1.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
// ... Hier Wirkfunktionen definieren
int main()
{ printtype( 3.1415926 ); ::std::cout << "\n"s; 
  printtype( 0         ); ::std::cout << "\n"s; }

std::cout

double 
int

Erweiterung von Funktionen

Eine Anwendung der Überladung von Funktionsnamen ist die Möglichkeit zur kompatiblen Erweiterung von Funktionsschnittstellen. Eine Funktion mag zunächst beispielsweise zwei Parameter haben. Es kann sich dann aber später herausstellen, daß es hilfreich wäre, einen weiteren Parameter zu der Funktion hinzuzufügen. Dann müßte alle Klienten der Funktion aber entsprechend angepaßt werden, was nicht immer möglich ist.

Dank der Möglichkeit zur Überladung von Funktionsnamen kann dann aber eine weitere Funktion mit gleichem Namen und einem zusätzlichen Parameter definiert werden, ohne daß die bisher schon existierende Funktionsdefinition mit zwei Parametern dazu verändert werden muß. Dann können die bisherigen Klienten weiterhin die bisherige Funktion mit zwei Parametern verwenden, während neuere Klienten die neue Funktion mit drei Parametern verwenden können.