Surcharge de fonction
C++ autorise la spécification de plusieurs fonctions du même nom dans la même portée.Celles-ci sont appelées fonctions surchargées et sont décrites en détail dans la surcharge.Les fonctions surchargées permettent aux programmeurs pour assurer la sémantique différente pour une fonction, selon les types et le nombre d'arguments.
Par exemple, une fonction de copie qui prend un argument de chaîne (ou char *) effectue des tâches très différentes qu'une acceptant un argument de type double.Surcharger permet l'uniforme d'attribution de noms et empêché les programmeurs d'assignation inventer des noms tels qu' print_sz ou print_d.Le tableau suivant montre les parties d'une déclaration de fonction C++ utilise pour différencier des groupes de fonctions avec le même nom dans la même portée.
considérations de surcharge
élément de déclaration de fonction |
utilisé pour surcharger ? |
|---|---|
Type de retour de la fonction |
Non |
Nombre d'arguments |
Oui |
type d'arguments |
Oui |
présence ou absence des points de suspension |
Oui |
utilisation des noms d' typedef |
Non |
Tailles de tableau non spécifiées |
Non |
const ou volatile (voir ci-dessous) |
Oui |
Bien que les fonctions puissent être distinguées en fonction de le type de retour, elles ne peuvent pas être surchargées sur cette base.Const ou volatile ne sont uniquement utilisés comme base pour la surcharge s'ils sont utilisés dans une classe pour appliquer à cela le pointeur de la classe, pas le type de retour de la fonction.En d'autres termes, la surcharge s'applique uniquement si le mot clé de const ou d' volatile suit la liste d'arguments de la fonction dans la déclaration.
Exemple
l'exemple suivant montre comment surcharger peut être utilisé.Une autre façon de résoudre le même problème est présentée dans arguments par défaut.
// 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();
}
Surcharger précédent de code suivant montre d' print s'exécutent dans la portée du fichier.
Pour les restrictions sur la surcharge et des informations sur comment surcharger affecte d'autres éléments de C++, consultez Surcharge.