Surcharge de fonction

C++ permet la spécification de plusieurs fonctions du même nom dans la même portée. Ces fonctions s'appellent des fonctions surchargées et sont décrites en détail dans Surcharge. Les fonctions surchargées permettent aux programmeurs de fournir une sémantique différente pour une fonction, selon les types et le nombre des arguments.

Par exemple, une fonction print qui accepte un argument de type chaîne (ou char *) effectue des tâches très différentes de celles d'une fonction qui accepte un argument de type double. La surcharge permet une appellation uniforme et évite aux programmeurs de devoir inventer des noms, par exemple print_sz ouprint_d. Le tableau suivant montre les parties qu'une déclaration de fonction C++ utilise pour différencier les groupes de fonctions portant le même nom dans la même portée.

Considérations en matière de surcharge

Bien que les fonctions puissent être distinguées en fonction du type de retour, elles ne peuvent pas être surchargées sur cette base. Les mots clés Const ou volatile sont utilisés uniquement comme base pour la surcharge s'ils sont utilisés dans une classe pour s'appliquer au pointeur this pour la classe et pas au type de retour de la fonction. En d'autres termes, la surcharge s'applique uniquement si le mot clé const ou volatile suit la liste d'arguments de la fonction dans la déclaration.

Exemple

L'exemple suivant illustre comment utiliser la surcharge. 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();
}

Le code précédent illustre la surcharge de la fonction print dans la portée de fichier.

Pour plus d'informations sur les restrictions concernant la surcharge et sur la façon dont la surcharge affecte les autres éléments de C++, consultez Surcharge.

Voir aussi

Référence

Déclarations de fonctions