Funktionsüberladung

C++ lässt die Angabe von mehr als einer Funktion mit dem gleichen Namen im gleichen Bereich.Diese werden überladene Funktionen bezeichnet und werden ausführlich im Überladen beschrieben.Überladene Funktionen können Programmierer, um andere Semantik für eine Funktion in Abhängigkeit von den Typen und der Argumentanzahl bereitstellen.

Zum Beispiel führt eine Drucken-Funktion, die ein Argument der Zeichenfolge (oder char *) akzeptiert als eine sehr unterschiedliche Aufgaben aus, die ein Argument des Typs doubleakzeptiert.Das Überladen ermöglicht einheitliche Benennungs- und verhindert, dass Programmierer am Namen oder print_sz müssen print_derfinden.Die folgende Tabelle zeigt, welche Teile einer Funktionsdeklaration C++ verwendet, um zwischen Gruppen Funktionen mit dem gleichen Namen im gleichen Bereich zu unterscheiden.

Überladen-Überlegungen

Obwohl Funktionen auf der Grundlage der Rückgabetyp definiert sein können, können sie nicht auf der Basis überladen werden.Const oder volatile werden nur als Grundlage für Überladen, wenn sie in einer Klasse verwendet werden, um zu dies den Zeiger auf die Klasse anwenden, nicht der Rückgabetyp der Funktion verwendet.Das heißt, Überladung gilt nur, wenn das const oder volatile-Schlüsselwort der Argumentliste der Funktion in der Deklaration folgt.

Beispiel

Das folgende Beispiel zeigt, wie das Überladen verwendet werden kann.Eine andere Möglichkeit, die gleiche Problem zu lösen wird in Standardargumentedargestellt.

// 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 Überladen des Operators print-Funktion im Dateigültigkeitsbereich an.

Weitere Einschränkungen und Informationen zum Überladen das Überladen andere Elemente von C++ auswirkt, finden Sie unter Überladen.

Siehe auch

Referenz

Funktionsdeklarationen