Sobrecarga de funciones y palabra clave const

La sobrecarga de funciones es una característica de la programación orientada a objetos en la que dos o más funciones pueden tener el mismo nombre pero diferentes parámetros. Cuando el nombre de una función se sobrecarga con diferentes trabajos, se denomina sobrecarga de funciones. En la sobrecarga de funciones, el nombre de la «función» debe ser el mismo y los argumentos deben ser diferentes. La sobrecarga de funciones se puede considerar como un ejemplo de una característica de polimorfismo en C++.

Los parámetros deben seguir una o más de las siguientes condiciones para la sobrecarga de funciones:

• Los parámetros deben tener un tipo diferente

sumar(int a, int b)
sumar(doble a, doble b)

A continuación se muestra la implementación de la discusión anterior:

#include <iostream>
using namespace std;
 
 
void add(int a, int b)
{
  cout << "sum = " << (a + b);
}
 
void add(double a, double b)
{
    cout << endl << "sum = " << (a + b);
}
 
// Driver code
int main()
{
    add(10, 2);
    add(5.3, 6.2);
 
    return 0;
}

sum = 12
sum = 11.5

• Los parámetros deben tener un número diferente 

sumar(int a, int b)
sumar(int a, int b, int c)

A continuación se muestra la implementación de la discusión anterior:

#include <iostream>
using namespace std;
 
void add(int a, int b)
{
  cout << "sum = " << (a + b);
}
 
void add(int a, int b, int c)
{
    cout << endl << "sum = " << (a + b + c);
}
 
// Driver code
int main()
{
    add(10, 2);
    add(5, 6, 4);
 
    return 0;
}

sum = 12
sum = 15

• Los parámetros deben tener una secuencia diferente de parámetros.

sumar(int a, doble b)
sumar(doble a, int b)

A continuación se muestra la implementación de la discusión anterior:

#include<iostream>
using namespace std;
 
void add(int a, double b)
{
    cout<<"sum = "<<(a+b);
} 
 
void  add(double a, int b)
{
    cout<<endl<<"sum = "<<(a+b);
} 
 
// Driver code
int main()
{
    add(10,2.5);
    add(5.5,6);
 
      return 0;
}

sum = 12.5
sum = 11.5

Prediga la salida del siguiente programa en C++. 

#include <iostream>
using namespace std;
 
class Test {
protected:
    int x;
 
public:
    Test(int i)
        : x(i)
    {
    }
    void fun() const
    {
        cout << "fun() const called " << endl;
    }
    void fun() { cout << "fun() called " << endl; }
};
 
int main()
{
    Test t1(10);
    const Test t2(20);
    t1.fun();
    t2.fun();
    return 0;
}

fun() called 
fun() const called 

Los dos métodos ‘void fun() const’ y ‘void fun()’ tienen la misma firma excepto que uno es const y el otro no. Además, si echamos un vistazo más de cerca a la salida, observamos que ‘const void fun()’ se llama en el objeto const, y ‘void fun()’ se llama en el objeto no const. C++ permite que los métodos miembro se sobrecarguen en función del tipo const. La sobrecarga en función del tipo constante puede ser útil cuando una función devuelve una referencia o un puntero. Podemos hacer una función const, que devuelve una referencia constante o un puntero constante, y otra función no constante, que devuelve una referencia o puntero no constante. Vea esto para más detalles. ¿Qué pasa con los parámetros?Las reglas relacionadas con los parámetros constantes son interesantes. Primero echemos un vistazo a los siguientes dos ejemplos. El programa 1 falla en la compilación, pero el programa 2 compila y funciona bien. 

// PROGRAM 1 (Fails in compilation)
#include<iostream>
using namespace std;
 
void fun(const int i)
{
    cout << "fun(const int) called ";
}
void fun(int i)
{
    cout << "fun(int ) called " ;
}
int main()
{
    const int i = 10;
    fun(i);
    return 0;
}

Producción:

Compiler Error: redefinition of 'void fun(int)'

// PROGRAM 2 (Compiles and runs fine)
#include<iostream>
using namespace std;
 
void fun(char *a)
{
cout << "non-const fun() " << a;
}
 
void fun(const char *a)
{
cout << "const fun() " << a;
}
 
int main()
{
const char *ptr = "GeeksforGeeks";
fun(ptr);
return 0;
}

const fun() GeeksforGeeks

C++ permite que las funciones se sobrecarguen en función de la const-ness de los parámetros solo si el parámetro const es una referencia o un puntero. Es por eso que el programa 1 falló en la compilación, pero el programa 2 funcionó bien. Esta regla en realidad tiene sentido. En el programa 1, el parámetro ‘i’ se pasa por valor, por lo que ‘i’ en fun() es una copia de ‘i’ en main(). Por lo tanto, fun() no puede modificar ‘i’ de main(). Por lo tanto, no importa si ‘i’ se recibe como un parámetro constante o como un parámetro normal. Cuando pasamos por referencia o puntero, podemos modificar el valor referido o apuntado, por lo que podemos tener dos versiones de una función, una que puede modificar el valor referido o apuntado, otra que no.

Como ejercicio, prediga la salida del siguiente programa. 

#include<iostream>
using namespace std;
 
void fun(const int &i)
{
    cout << "fun(const int &) called ";
}
void fun(int &i)
{
    cout << "fun(int &) called " ;
}
int main()
{
    const int i = 10;
    fun(i);
    return 0;
}

fun(const int &) called 

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.