Argumentos predeterminados en C++

Un argumento predeterminado es un valor proporcionado en una declaración de función que el compilador asigna automáticamente si la función que llama no proporciona un valor para el argumento. En caso de que se pase algún valor, se anula el valor predeterminado. 

1) El siguiente es un ejemplo simple de C++ para demostrar el uso de argumentos predeterminados. Aquí, no tenemos que escribir 3 funciones de suma; solo una función funciona usando los valores predeterminados para los argumentos 3 y 4. 

// CPP Program to demonstrate Default Arguments
#include <iostream>
using namespace std;
 
// A function with default arguments,
// it can be called with
// 2 arguments or 3 arguments or 4 arguments.
int sum(int x, int y, int z = 0, int w = 0) //assigning default values to z,w as 0
{
    return (x + y + z + w);
}
 
// Driver Code
int main()
{
    // Statement 1
    cout << sum(10, 15) << endl;
   
    // Statement 2
    cout << sum(10, 15, 25) << endl;
   
    // Statement 3
    cout << sum(10, 15, 25, 30) << endl;
    return 0;
}

25
50
80

Explicación: en la declaración 1, solo se pasan dos valores, por lo tanto, las variables z y w toman los valores predeterminados de 0. En la declaración 2, se pasan tres valores, por lo que el valor de z se anula con 25. En la declaración 3, cuatro valores se pasan, por lo que los valores de z y w se anulan con 25 y 30 respectivamente.

2) Si la sobrecarga de funciones se realiza con los argumentos predeterminados, entonces debemos asegurarnos de que no sea ambiguo para el compilador, de lo contrario arrojará un error. La siguiente es la versión modificada del programa anterior:

// CPP Program to demonstrate Function overloading in
// Default Arguments
#include <iostream>
using namespace std;
 
// A function with default arguments, it can be called with
// 2 arguments or 3 arguments or 4 arguments.
int sum(int x, int y, int z = 0, int w = 0)
{
    return (x + y + z + w);
}
int sum(int x, int y, float z = 0, float w = 0)
{
    return (x + y + z + w);
}
// Driver Code
int main()
{
    cout << sum(10, 15) << endl;
    cout << sum(10, 15, 25) << endl;
    cout << sum(10, 15, 25, 30) << endl;
    return 0;
}

Error: 

prog.cpp: In function 'int main()':
prog.cpp:17:20: error: call of overloaded 
'sum(int, int)' is ambiguous
  cout << sum(10, 15) << endl; 
                    ^
prog.cpp:6:5: note: candidate: 
int sum(int, int, int, int)
 int sum(int x, int y, int z=0, int w=0) 
     ^
prog.cpp:10:5: note: candidate: 
int sum(int, int, float, float)
 int sum(int x, int y, float z=0, float w=0) 
     ^

3) Un constructor también puede contener parámetros predeterminados. Un constructor predeterminado puede no tener parámetros o parámetros con argumentos predeterminados.

// CPP code to demonstrate use of default arguments in
// Constructors
 
#include <iostream>
using namespace std;
class A {
public:
    int sum = 0;
    A(); // default constructor with no argument
    A(int x = 0); // default constructor with one
                        // arguments
     
};

Explicación : aquí vemos un constructor predeterminado sin argumentos y un constructor predeterminado con un argumento predeterminado. El constructor predeterminado con argumento tiene un parámetro predeterminado x, al que se le ha asignado un valor de 0. 

Puntos clave:  

• Los argumentos predeterminados son diferentes de los argumentos constantes, ya que los argumentos constantes no se pueden cambiar, mientras que los argumentos predeterminados se pueden sobrescribir si es necesario.
• Los argumentos predeterminados se sobrescriben cuando la función de llamada proporciona valores para ellos. Por ejemplo, llamar a la función sum(10, 15, 25, 30) sobrescribe los valores de z y w a 25 y 30 respectivamente.
• Cuando se llama a una función, los argumentos se copian de la función que llama a la función llamada en el orden de izquierda a derecha. Por lo tanto, sum(10, 15, 25) asignará 10, 15 y 25 a x, y y z respectivamente, lo que significa que solo se usa el valor predeterminado de w.
• Una vez que se utiliza un valor predeterminado para un argumento en la definición de la función, todos los argumentos posteriores también deben tener un valor predeterminado. También se puede afirmar que los argumentos predeterminados se asignan de derecha a izquierda. Por ejemplo, la siguiente definición de función no es válida ya que el argumento subsiguiente de la variable predeterminada z no es predeterminado.

// Invalid because z has default value, but w after it doesn't have a default value
int sum(int x, int y, int z = 0, int w).

Ventajas de los argumentos predeterminados:

• Los argumentos predeterminados son útiles cuando queremos aumentar las capacidades de una función existente, ya que podemos hacerlo simplemente agregando otro argumento predeterminado a la función.
• Ayuda a reducir el tamaño de un programa.
• Proporciona un enfoque de programación simple y efectivo.
• Los argumentos predeterminados mejoran la consistencia de un programa.

Desventajas de los argumentos predeterminados:

• Aumenta el tiempo de ejecución ya que el compilador necesita reemplazar los argumentos omitidos por sus valores predeterminados en la llamada a la función.