Overload di funzioni
C++ consente la specifica di più funzioni con lo stesso nome nello stesso ambito. Si tratta di funzioni in overload e vengono descritte in dettaglio in Overload. Le funzioni in overload consentono ai programmatori di fornire diverse semantiche per una funzione, in base ai tipi e al numero di argomenti.
Ad esempio, una funzione print che accetta un argomento (o char *) di stringa esegue attività molto diverse rispetto a chi accetta un argomento di tipo doppio. L'overload consente una denominazione uniforme e impedisce ai programmatori di dover inventare nomi quali print_sz o print_d. Nella tabella seguente sono illustrate quali parti di una dichiarazione di funzione C++ vengono utilizzate per distinguere tra gruppi di funzioni con lo stesso nome nello stesso ambito.
Considerazioni sull'overload
Elemento di dichiarazione della funzione |
Utilizzato per eseguire l'overload? |
|---|---|
Tipo restituito di funzione |
No |
Numero di argomenti |
Yes |
Tipo di argomenti |
Yes |
Presenza o assenza di puntini di sospensione |
Yes |
Utilizzo dei nomi typedef |
No |
Limiti di matrice non specificati |
No |
const o volatile (vedere di seguito) |
Yes |
Sebbene le funzioni possono essere distinte in base al tipo restituito, non è possibile eseguire l'overload su questa base. Const o volatile vengono utilizzati solo come base per eseguire l'overload se sono utilizzati in una classe da applicare a questo puntatore per la classe, non il tipo restituito della funzione. In altre parole, l'overload si applica solo se la parola chiave volatile o const segue l'elenco di argomenti della funzione nella dichiarazione.
Esempio
Nell'esempio seguente viene illustrato come è possibile utilizzare l'overload. Un altro modo per risolvere lo stesso problema viene presentato in Argomenti predefiniti.
// 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();
}
Nel codice precedente viene illustrato l'overload della funzione print nell'ambito file.
Per le limitazioni relative all'overload e per informazioni su l'overload influisce su altri elementi di C++, vedere Overload.