La sobrecarga de operadores es, en esencia, una forma de syntactic sugar que permite aplicar símbolos matemáticos o lógicos a tipos de datos personalizados. No estamos creando operadores nuevos; simplemente estamos definiendo cómo debe comportarse un operador existente cuando se aplica a nuestras clases. Internamente, el compilador traduce cada uso de un operador en una llamada a una función con una firma específica. Por ejemplo, a + b se transforma en a.operator+(b) si es una función miembro, o en operator+(a, b) si es una función libre.
Esta técnica se utiliza para que nuestros tipos propios (como una matriz, un complejo o un iterador) se sientan como “tipos nativos” del lenguaje. Es ideal cuando la semántica es obvia y natural: sumar dos vectores debe devolver un vector, no un entero. Sin embargo, si la sobrecarga no es intuitiva —como usar * para realizar una operación de división—, el código se vuelve ilegible y propenso a errores catastróficos.
El uso de funciones miembro frente a funciones libres es la decisión de diseño más crítica. Al definir un operador binario como función miembro, el objeto de la izquierda (this) actúa como el primer operando. Esto crea una asimetría: vector + 5.0 funciona si operator+(double) es miembro, pero 5.0 + vector fallará porque el double no puede llamar a un método de nuestra clase. Las funciones libres, al recibir ambos operandos como parámetros, permiten la conversión implícita en ambos lados, manteniendo la simetría.
Si aplicas mal la sobrecarga, el problema más grave es la pérdida de la semántica esperada o la creación de efectos secundarios inesperados (como que un + modifique el objeto original). Además, ignorar las reglas de las funciones miembro —como operator[] o operator() que están obligatoriamente restringidos a ser miembros— resultará en un error de compilación inmediato.
#include <iostream>
#include <compare> // [C++20] para <=>
#include <array>
struct Vector2D {
std::array<double, 2> coords;
double x() const { return coords[0]; }
double y() const { return coords[1]; }
// Operador de asignación y suma (binario, miembro)
// Implementar como miembro para permitir `v1 = v1 + v2`
Vector2D& operator+=(const Vector2D& other) {
coords[0] += other.coords[0];
coords[1] += other.coords[1];
return *this;
}
// Operador de comparación [C++20]
// 'default' genera automáticamente ==, !=, <, <=, >, >=
auto operator<=>(const Vector2D&) const = default;
// Operadores de incremento (prefix y postfix)
Vector2D& operator++() { // Prefijo: devuelve referencia
coords[0]++;
coords[1]++;
return *this;
}
Vector2D operator++(int) { // Postfijo: devuelve copia (el 'int' es un tag)
Vector2D temp = *this;
++(*this);
return temp;
}
// Operador de indexación (obligatoriamente miembro)
double& operator[](size_t i) { return coords[i]; }
const double operator[](size_t i) const { return coords[i]; }
// Operador de llamada (functor)
void operator()(double escala) {
coords[0] *= escala;
coords[1] *= escala;
}
};
// Operador de flujo (obligatoriamente función libre/amiga)
// Debe ser libre porque el primer operando es std::ostream
std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
return os << "(" << v.x() << ", " << v.y() << ")";
}
int main() {
Vector2D v1{{1.0, 2.0}};
Vector2D v2{{3.0, 4.0}};
// Uso de operador de suma (v1 + v2 invoca a v1.operator+(v2))
// Nota: Para que v1 + v2 funcione siendo v1 miembro,
// deberíamos haber definido operator+ además de operator+=.
// Para este ejemplo, usaremos += para simplificar.
v1 += v2;
std::cout << "Suma: " << v1 << "\n"; // Usa operator<<
if (v1 > v2) { // Usa el <=> generado por default
std::cout << "v1 es mayor que v2\n";
}
++v1; // Prefijo
std::cout << "Tras incremento: " << v1 << "\n";
v1(2.0); // Llama a operator()
std::cout << "Tras escalar por 2: " << v1 << "\n";
return 0;
}
Desglose del código
En el ejemplo, operator<=> [C++20] es la clave de la modernidad. Al marcarlo como = default, el compilador implementa la comparación lexicográfica de los miembros de la estructura. Esto sustituye la antigua y tediosa práctica de sobrecargar manualmente todos los operadores de comparación (==, !=, <, etc.) o usar std::rel_ops [C++14].
Observa la diferencia entre los incrementos. El prefijo operator++() devuelve una referencia (Vector2D&), lo cual es eficiente y permite encadenamiento (++(++v)). El postfijo operator++(int) recibe un parámetro int que el compilador usa como marcador (tag) para diferenciarlo, y debe devolver una copia del objeto original antes de ser modificado, para que la expresión v++ sea semánticamente correcta.
El operador operator[] se ha implementado en dos versiones: una para objetos mutables y otra const para objetos inmutables. Esto es vital para la const-correctness. Si intentas acceder a un elemento de un Vector2D dentro de una función que recibe el vector por const&, solo podrás usar la versión const del operador.
Finalmente, operator<< es una función libre. Si intentáramos declararlo como miembro de Vector2D, el compilador esperaría que la sintaxis fuera v1 << std::cout, lo cual es contraintuitivo. Al definirlo fuera (o como friend), permitimos que std::cout << v1 funcione, posicionando al flujo de salida como el primer operando.
El error frecuente
Un error clásico al implementar operator[] es olvidar la versión const.
// ERROR: Solo proveemos versión mutante
struct Contenedor {
int datos[10];
int& operator[](size_t i) { return datos[i]; }
};
void imprimir(const Contenedor& c) {
// ERROR DE COMPILACIÓN: No se puede llamar a un operador
// no-const en un objeto const.
std::cout << c[0];
}
Si un objeto es const, el compilador buscará una sobrecarga que acepte un objeto const. Si solo tienes la versión que devuelve int&, el compilador fallará porque no puede garantizar que la llamada no modifique el objeto. La solución es siempre proporcionar ambas: la versión mutante para lectura/escritura y la versión const para lectura en objetos inmutables.
N° 44