Dominando la Sobrecarga en C++: Funciones y Operadores Explicados

C++ te permite especificar más de una definición para un nombre de función o un operador en el mismo alcance, lo que se llama sobrecarga de funciones y sobrecarga de operadores respectivamente.

Una declaración sobrecargada es una declaración que se declara con el mismo nombre que una declaración previamente declarada en el mismo alcance, excepto que ambas declaraciones tienen diferentes argumentos y obviamente diferente definición (implementación).

Cuando llamas a una función o operador sobrecargado, el compilador determina la definición más apropiada para usar, comparando los tipos de argumentos que has usado para llamar a la función u operador con los tipos de parámetros especificados en las definiciones. El proceso de seleccionar la función u operador sobrecargado más apropiado se llama resolución de sobrecarga.

Sobrecarga de Funciones en C++

Puedes tener múltiples definiciones para el mismo nombre de función en el mismo alcance. La definición de la función debe diferir entre sí por los tipos y/o el número de argumentos en la lista de argumentos. No puedes sobrecargar declaraciones de función que difieran solo por tipo de retorno.

El siguiente es un ejemplo donde la misma función imprimir() se está usando para imprimir diferentes tipos de datos:

#include <iostream>
using namespace std;
class imprimirDatos {
public:
    void imprimir(int i) {
        cout << "Imprimiendo int: " << i << endl;
    }
    void imprimir(double f) {
        cout << "Imprimiendo float: " << f << endl;
    }
    void imprimir(char* c) {
        cout << "Imprimiendo carácter: " << c << endl;
    }
};
int main(void) {
    imprimirDatos pd;
    // Llamar imprimir para imprimir entero
    pd.imprimir(5);
    // Llamar imprimir para imprimir float
    pd.imprimir(500.263);
    // Llamar imprimir para imprimir carácter
    pd.imprimir("Hola C++");
    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Imprimiendo int: 5
Imprimiendo float: 500.263
Imprimiendo carácter: Hola C++

Sobrecarga de Operadores en C++

Puedes redefinir o sobrecargar la mayoría de los operadores integrados disponibles en C++. Así, un programador puede usar operadores con tipos definidos por el usuario también.

Los operadores sobrecargados son funciones con nombres especiales: la palabra clave "operator" seguida por el símbolo del operador que se está definiendo. Como cualquier otra función, un operador sobrecargado tiene un tipo de retorno y una lista de parámetros.

Caja operator+(const Caja&);

declara el operador de adición que puede usarse para sumar dos objetos Caja y retorna el objeto Caja final. La mayoría de los operadores sobrecargados pueden definirse como funciones ordinarias no-miembro o como funciones miembro de clase. En caso de que definamos la función anterior como función no-miembro de una clase, entonces tendríamos que pasar dos argumentos para cada operando de la siguiente manera:

Caja operator+(const Caja&, const Caja&);

El siguiente es un ejemplo para mostrar el concepto de sobrecarga de operadores usando una función miembro. Aquí se pasa un objeto como argumento cuyas propiedades serán accedidas usando este objeto, el objeto que llamará a este operador puede ser accedido usando el operador this como se explica a continuación:

#include <iostream>
using namespace std;
class Caja {
public:
    double obtenerVolumen(void) {
        return largo * ancho * alto;
    }
    void establecerLargo(double len) { largo = len; }
    void establecerAncho(double bre) { ancho = bre; }
    void establecerAlto(double hei) { alto = hei; }
    // Sobrecargar operador + para sumar dos objetos Caja.
    Caja operator+(const Caja& b) {
        Caja caja;
        caja.largo = this->largo + b.largo;
        caja.ancho = this->ancho + b.ancho;
        caja.alto = this->alto + b.alto;
        return caja;
    }
private:
    double largo;   // Largo de una caja
    double ancho;   // Ancho de una caja
    double alto;    // Alto de una caja
};
// Función principal para el programa
int main() {
    Caja Caja1; // Declarar Caja1 de tipo Caja
    Caja Caja2; // Declarar Caja2 de tipo Caja
    Caja Caja3; // Declarar Caja3 de tipo Caja
    double volumen = 0.0; // Almacenar el volumen de una caja aquí
    // especificación caja 1
    Caja1.establecerLargo(6.0);
    Caja1.establecerAncho(7.0);
    Caja1.establecerAlto(5.0);
    // especificación caja 2
    Caja2.establecerLargo(12.0);
    Caja2.establecerAncho(13.0);
    Caja2.establecerAlto(10.0);
    // volumen de caja 1
    volumen = Caja1.obtenerVolumen();
    cout << "Volumen de Caja1: " << volumen << endl;
    // volumen de caja 2
    volumen = Caja2.obtenerVolumen();
    cout << "Volumen de Caja2: " << volumen << endl;
    // Sumar dos objetos como sigue:
    Caja3 = Caja1 + Caja2;
    // volumen de caja 3
    volumen = Caja3.obtenerVolumen();
    cout << "Volumen de Caja3: " << volumen << endl;
    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Volumen de Caja1: 210
Volumen de Caja2: 1560
Volumen de Caja3: 5400

Operadores Sobrecargables/No Sobrecargables

La siguiente es la lista de operadores que pueden ser sobrecargados:

La siguiente es la lista de operadores que no pueden ser sobrecargados:

Ejemplos de Sobrecarga de Operadores

Aquí hay varios ejemplos de sobrecarga de operadores para ayudarte a entender el concepto.