Sobrecarga de operadores en C++: Guía práctica con ejemplos de código

¿Qué es la sobrecarga de operadores?

Usando la sobrecarga de operadores en C++, puede asignar múltiples significados a un operador dentro del mismo ámbito. El objetivo es dar un comportamiento personalizado a un operador para un tipo definido por el usuario.

Con la sobrecarga de operadores, puede redefinir la mayoría de operadores de C++ y realizar diferentes operaciones usando un solo símbolo.

En este tutorial aprenderá:

• Qué es la sobrecarga de operadores
• Sintaxis
• Diferentes enfoques para sobrecargar operadores en C++
• Qué operadores no pueden sobrecargarse
• Consideraciones clave
• Reglas para la sobrecarga de operadores
• Cómo sobrecargar un operador en la práctica

Sintaxis

Para sobrecargar un operador de C++, defina una función miembro especial dentro de una clase de la siguiente forma:

class nombre_clase {
    ...
public:
    tipo_retorno operator símbolo (argumento(s)) {
        ...
    }
    ...
};

Los componentes son:

• tipo_retorno – el tipo devuelto por la función operador.
• operator – la palabra clave que inicia la declaración.
• símbolo – el operador que desea sobrecargar, ej. +, -, <, ++.
• argumento(s) – parámetros, como cualquier otra función.

Ejemplo 1:

#include <iostream>
using namespace std;
class ClasePrueba {
private:
    int contador;
public:
    ClasePrueba() : contador(5) {}
    void operator --() {
        contador = contador - 3;
    }
    void Mostrar() {
        cout << "Contador: " << contador;
    }
};
int main() {
    ClasePrueba cp;
    --cp;
    cp.Mostrar();
    return 0;
}

Salida:

Captura del código:

Explicación del código:

1. Incluya <iostream> para acceder a facilidades de E/S.
2. Use el espacio de nombres std por brevedad.
3. Defina una clase ClasePrueba.
4. Haga contador miembro privado.
5. Proporcione constructor público que inicialice contador a 5.
6. Sobrecargue el operador prefijo -- para restar 3 a contador.
7. Implemente Mostrar() para imprimir el valor actual.
8. En main(), cree una instancia, aplique el operador sobrecargado y muestre el resultado.

Diferentes enfoques para la sobrecarga de operadores en C++

La sobrecarga puede lograrse mediante:

1. Funciones miembro
2. Funciones no miembro (amigas o libres)
3. Funciones amigas (cuando se necesita acceso a datos privados)

• Si el operando izquierdo es un objeto de la clase, típicamente se usa una función miembro.
• Cuando el operando izquierdo es de tipo diferente, se requiere una función no miembro.
• Las funciones amigas son útiles cuando el operador necesita acceder a miembros privados o protegidos.

¿Pueden sobrecargarse todos los operadores de C++?

No. Los siguientes operadores no son sobrecargables:

• :: – resolución de ámbito
• ?: – condicional ternario
• . – acceso a miembro
• sizeof – consulta de tamaño
• * (selector de puntero a miembro)

Cosas que recordar

1. La sobrecarga solo afecta a tipos definidos por el usuario; los tipos integrados conservan su comportamiento original.
2. Los operadores de asignación (=) y dirección (&) se sobrecargan automáticamente para clases que proporcionan constructores de copia u operadores de asignación.
3. La precedencia de operadores permanece inalterada; puede usar paréntesis para forzar orden de evaluación.
4. Tres operadores —::, ., ?:— están explícitamente prohibidos de sobrecargar.

Reglas para la sobrecarga de operadores

• Al menos un operando debe ser de tipo clase definido por el usuario.
• Solo operadores existentes pueden sobrecargarse; no puede introducir nuevos símbolos de operador.
• Algunos operadores (ej. new, delete) no pueden sobrecargarse como funciones amigas pero sí como funciones miembro.

Cómo sobrecargar un operador

Ejemplo 1: Operador de incremento

#include <iostream>
using namespace std;
class SobrecargaOperador {
private:
    int x;
public:
    SobrecargaOperador() : x(10) {}
    void operator ++() {
        x += 2;
    }
    void Imprimir() {
        cout << "El contador es: " << x;
    }
};
int main() {
    SobrecargaOperador so;
    ++so;
    so.Imprimir();
    return 0;
}

Salida:

Captura del código:

Explicación del código:

1. Incluya <iostream> y use el espacio de nombres std.
2. Defina clase SobrecargaOperador con int x privado.
3. Constructor inicializa x a 10.
4. Sobrecargue el operador prefijo ++ para sumar 2 a x.
5. Implemente Imprimir() para mostrar el valor actualizado.
6. En main(), cree un objeto, invoque el operador sobrecargado e imprima el resultado.

Ejemplo 2: Adición de números complejos

#include <iostream>
using namespace std;
class ClasePrueba {
private:
    int real, imag;
public:
    ClasePrueba(int rl = 0, int im = 0) : real(rl), imag(im) {}
    ClasePrueba operator + (ClasePrueba const &obj) {
        ClasePrueba resultado;
        resultado.real = real + obj.real;
        resultado.imag = imag + obj.imag;
        return resultado;
    }
    void imprimir() {
        cout << real << " + i" << imag << endl;
    }
};
int main() {
    ClasePrueba c1(9, 5), c2(4, 3);
    ClasePrueba c3 = c1 + c2;
    c3.imprimir();
} 

Salida:

Captura del código:

Explicación del código:

1. Incluya <iostream> y use el espacio de nombres std.
2. Defina ClasePrueba con componentes real e imag.
3. Proporcione constructor para inicialización.
4. Sobrecargue el operador + para realizar adición de números complejos.
5. Retorne una nueva instancia ClasePrueba conteniendo la suma.
6. Implemente imprimir() para mostrar el número complejo.
7. En main(), cree dos instancias, súmelas e imprima el resultado.

Resumen

• La sobrecarga de operadores permite múltiples significados para un operador dentro de un ámbito.
• Proporciona comportamiento personalizado para tipos definidos por el usuario.
• La mayoría de operadores de C++ pueden sobrecargarse, pero algunos no.
• Al menos un operando debe ser un tipo definido por el usuario.
• Solo operadores existentes son sobrecargables.