Funktionsüberladung

C++ lässt die Angabe mehrerer Funktionen mit dem gleichen Namen im gleichen Gültigkeitsbereich zu. Diese werden als überladene Funktionen bezeichnet und ausführlich unter "Überladen" beschrieben. Überladene Funktionen ermöglichen Programmierern das Bereitstellen anderer Semantiken für eine Funktion in Abhängigkeit von den Typen und der Anzahl von Argumenten.

Zum Beispiel führt eine print-Funktion, die ein Zeichenfolgen- (oder char *)-Argument akzeptiert, Aufgaben aus, die sich deutlich von den Aufgaben einer Funktion unterscheiden, die Argumente vom Typ double akzeptiert. Das Überladen ermöglicht eine einheitliche Benennung und verhindert, dass Programmierer Namen wie print_sz oder print_d erfinden müssen. Die folgende Tabelle zeigt, welche Teile einer Funktionsdeklaration von C++ verwendet werden, um zwischen Gruppen von Funktionen mit dem gleichen Namen und dem gleichen Gültigkeitsbereich zu differenzieren.

Überlegungen zur Überladung

Funktionsdeklarationselement	Wird zum Überladen verwendet?
Funktionsrückgabetyp	Nein
Anzahl der Argumente	Ja
Typ der Argumente	Ja
Vorhandensein oder Abwesenheit von Auslassungszeichen	Ja
Verwendung von typedef-Namen	Nein
Nicht angegebene Arraygrenzen	Nein
const oder volatile (siehe unten)	Ja

Obwohl diese Funktionen anhand des Rückgabetyps unterschieden werden können, können sie auf dieser Grundlage nicht überladen werden. Const oder volatile werden nur als Grundlage zum Überladen verwendet, wenn sie in einer Klasse verwendet werden, die auf den this-Zeiger für die Klasse, nicht auf den Rückgabetyp der Funktion angewendet werden soll. Das heißt, Überladung gilt nur, wenn das Schlüsselwort const oder volatile der Argumentliste der Funktion in der Deklaration folgt.

Beispiel

Das folgende Beispiel veranschaulicht, wie das Überladen verwendet werden kann. Eine andere Möglichkeit zur Lösung des gleichen Problems wird unter Standardargumente dargestellt.

// function_overloading.cpp
// compile with: /EHsc
#include <iostream>
#include <math.h>

// Prototype three print functions.
int print( char *s );                  // Print a string.
int print( double dvalue );            // Print a double.
int print( double dvalue, int prec );  // Print a double with a
//  given precision.
using namespace std;
int main( int argc, char *argv[] )
{
const double d = 893094.2987;
if( argc < 2 )
    {
// These calls to print invoke print( char *s ).
print( "This program requires one argument." );
print( "The argument specifies the number of" );
print( "digits precision for the second number" );
print( "printed." );
exit(0);
    }

// Invoke print( double dvalue ).
print( d );

// Invoke print( double dvalue, int prec ).
print( d, atoi( argv[1] ) );
}

// Print a string.
int print( char *s )
{
cout << s << endl;
return cout.good();
}

// Print a double in default precision.
int print( double dvalue )
{
cout << dvalue << endl;
return cout.good();
}

// Print a double in specified precision.
//  Positive numbers for precision indicate how many digits
//  precision after the decimal point to show. Negative
//  numbers for precision indicate where to round the number
//  to the left of the decimal point.
int print( double dvalue, int prec )
{
// Use table-lookup for rounding/truncation.
static const double rgPow10[] = { 
10E-7, 10E-6, 10E-5, 10E-4, 10E-3, 10E-2, 10E-1, 10E0,
10E1,  10E2,  10E3,  10E4, 10E5,  10E6
    };
const int iPowZero = 6;
// If precision out of range, just print the number.
if( prec < -6 || prec > 7 )
return print( dvalue );
// Scale, truncate, then rescale.
dvalue = floor( dvalue / rgPow10[iPowZero - prec] ) *
rgPow10[iPowZero - prec];
cout << dvalue << endl;
return cout.good();
}

Der vorhergehende Code zeigt das Überladen der print-Funktion im Dateigültigkeitsbereich an.

Weitere Einschränkungen beim Überladen und Informationen dazu, wie sich das Überladen auf andere Elemente von C++ auswirkt, finden Sie unter Überladen.

Siehe auch

Referenz

Funktionsdeklarationen