La sobrecarga de la función

C++ permite la especificación de más de una función del mismo nombre en el mismo ámbito.Se llama a las funciones sobrecargadas y se describen detalladamente en la sobrecarga.Las funciones sobrecargadas permiten a los programadores para proporcionar una semántica diferente a para una función, dependiendo de los tipos y el número de argumentos.

Por ejemplo, una función de impresión que toma un argumento de cadena (o char *) realiza tareas muy diferentes que toma un argumento de Dobleescrito.La sobrecarga permite el URI que llama y evita que los programadores tengan que inventar nombres como print_sz o print_d.La tabla siguiente muestra las partes de una declaración de función C++ utiliza para distinguir entre grupos de funciones con el mismo nombre en el mismo ámbito.

sobrecargar consideraciones

Aunque las funciones pueden ser distinguen en función del tipo de valor devuelto, no pueden sobrecargar en esta base.Const o volatile solo se utiliza como base para sobrecargar si se utilizan en una clase para solicitar el puntero de this la clase, no el tipo de valor devuelto de la función.Es decir sobrecarga solo se aplica si la palabra clave de const o de volatile sigue la lista de argumentos de la función en la declaración.

Ejemplo

El ejemplo siguiente se muestra cómo la sobrecarga puede utilizar.Otra manera de resolver el mismo problema se muestra en establezca como valor predeterminado los argumentos.

// 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 sobrecarga de funciones de print en el ámbito del archivo.

Para las restricciones en la sobrecarga e información sobre cómo la sobrecarga afecta a otros elementos de C++, vea La sobrecarga.

Vea también

Referencia

Declaraciones de función