Operadores en C++ como magia: reglas de sobrecarga para principiantes

Introducción: ¿por qué tu código no se parece a la magia?

Imagina que estás escribiendo un programa en C++ y necesitas comparar dos números complejos. Escribes if (a > b) — y el compilador da un error. «¿Por qué?», te preguntas. Porque el compilador no sabe qué significa «mayor que» para tu propio tipo de datos.

En C++, los operadores no son solo garabatos en el teclado. Son una herramienta poderosa que permite que tu código se vea natural, como en matemáticas o en Python. La sobrecarga de operadores (operator overloading) es una forma de enseñar al compilador a trabajar con tus clases de manera tan intuitiva como con los tipos incorporados. Hoy analizaremos las reglas básicas y los modismos que transformarán tu código de un conjunto aburrido de funciones en un elegante «lenguaje de programación» dentro de C++.

Este material se basa en una pregunta real de Stack Overflow que acumuló miles de visitas. Lo hemos adaptado para principiantes, para que no solo copies ejemplos, sino que entiendas por qué se debe hacer de una manera y no de otra.

Regla n.º 1: «No reinventes la rueda» — cuándo está justificada la sobrecarga

Lo primero que debes asimilar: la sobrecarga de operadores no es una fiesta a la que debas invitar a todos. Sobrecarga operadores solo cuando esto haga que el código sea más obvio. Si creas una clase Vector, la sobrecarga de + para sumar vectores es totalmente lógica. Pero para una clase BaseDeDatos, el operador + se vería extraño y sería engañoso.

La regla de oro: la semántica del operador debe ser intuitivamente clara. El usuario de tu clase (o tú mismo dentro de un mes) debe entender de un vistazo qué hace a + b.

Cuándo no sobrecargar

\n
• Si el operador no tiene un significado obvio para tu tipo (por ejemplo, operator+ para una clase «Persona»).
\n
• Si puedes arreglártelas con una función normal con un nombre descriptivo (add(), merge()).
\n
• Si no planeas mantener la semántica estándar (el operador + no debe modificar sus argumentos).
\n

Regla n.º 2: El operador de asignación — el rey de los modismos

El operador más común y más traicionero es el operador de asignación (operator=). Sin él, tu clase funcionará, pero solo hasta que empieces a copiar objetos. Y aquí es donde comienza lo interesante.

El modismo principal para operator= es copy-and-swap (copiar e intercambiar). ¿Por qué es tan bueno? Porque resuelve tres problemas a la vez:

\n
• Protección contra la autoasignación (a = a).
\n
• Seguridad excepcional (si la copia lanza una excepción, el objeto original permanece intacto).
\n
• Simplicidad y legibilidad del código.
\n

Así es como se ve en la práctica:

class MyString {\nprivate:\n    char* data;\n    size_t size;\n\npublic:\n    // Constructor de copia\n    MyString(const MyString& other) : size(other.size) {\n        data = new char[size + 1];\n        std::copy(other.data, other.data + size + 1, data);\n    }\n\n    // Destructor\n    ~MyString() { delete[] data; }\n\n    // Operador de asignación mediante copy-and-swap\n    MyString& operator=(MyString other) { // 1. Se recibe por valor\n        std::swap(data, other.data);       // 2. Intercambiamos datos\n        std::swap(size, other.size);\n        return *this;                      // 3. Devolvemos la referencia\n    } // 4. El objeto antiguo se destruye en el destructor de other\n};

Observa: other se pasa por valor, no por referencia. Este es el punto clave: el constructor de copia crea una copia temporal, y simplemente intercambiamos datos con ella. Los datos antiguos se liberan automáticamente cuando el objeto temporal se