Sobrecarga de funciones
C++ permite especificar más de una función del mismo nombre en el mismo ámbito. Estas funciones reciben el nombre de funciones sobrecargadas y se describen detalladamente en el tema Sobrecarga. Las funciones sobrecargadas permiten a los programadores proporcionar una semántica diferente para una función, dependiendo de los tipos y el número de argumentos.
Por ejemplo, una función print que tome un argumento de cadena (o char *) realizará tareas muy diferentes que una que tome un argumento de tipo double. La sobrecarga permite usar una nomenclatura uniforme y evita que los programadores tengan que inventarse nombres como print_sz o print_d. En la tabla siguiente se muestran las partes de una declaración de función que usa C++ para distinguir entre grupos de funciones con el mismo nombre en el mismo ámbito.
Consideraciones sobre la sobrecarga
Elemento de declaración de función |
¿Se usa para la sobrecarga? |
|---|---|
Tipo de valor devuelto de la función |
No |
Número de argumentos |
Sí |
Tipo de argumentos |
Sí |
Presencia o ausencia de puntos suspensivos |
Sí |
Uso de nombres typedef |
No |
Límites de matriz sin especificar |
No |
const o volatile (véase a continuación) |
Sí |
Aunque las funciones se pueden distinguir en función del tipo de valor devuelto, no pueden sobrecargarse de acuerdo con este criterio. Const o volatile solo se utilizan como criterios para la sobrecarga si se usan en una clase para aplicarse al puntero this de la clase, no al tipo de valor devuelto de la función. Es decir, la sobrecarga solo se aplica si la palabra clave const o volatile sigue la lista de argumentos de la función en la declaración.
Ejemplo
En el ejemplo siguiente se muestra cómo se puede usar la sobrecarga. En Argumentos predeterminados se muestra otra manera de resolver el mismo problema.
// 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();
}
El código anterior muestra la sobrecarga de la función print en el ámbito del archivo.
Para conocer las restricciones de la sobrecarga y obtener información sobre cómo la sobrecarga afecta a otros elementos de C++, vea Sobrecarga.