Introducción a la sobrecarga de operadores

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 40 de 104.

La sobrecarga de operadores te permite definir cómo se comportan los operadores como +, - o == cuando se usan con tus clases personalizadas. En lugar de llamar a métodos como a.add(b), puedes escribir el más intuitivo a + b.

En C++, los operadores son esencialmente funciones con nombres especiales. Para sobrecargar un operador, se define una función utilizando la palabra clave operator seguida del símbolo:

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Sobrecargar el operador +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Ahora puedes sumar dos vectores de forma natural:

Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;    // Llama a v1.operator+(v2)

No todos los operadores pueden ser sobrecargados. El operador de resolución de ámbito ::, el acceso a miembros ., el ternario ?: y sizeof no pueden ser sobrecargados. Además, no se pueden crear nuevos operadores ni cambiar la precedencia de un operador: * siempre se evaluará antes que +.

Los operadores pueden implementarse como funciones miembro (como arriba) o como funciones no miembro. En las próximas lecciones, aprenderás cuándo usar cada enfoque y cómo sobrecargar categorías específicas de operadores.

Desafío

Fácil

Vamos a construir una clase Point que represente una coordenada 2D y admita la suma de dos puntos utilizando el operador +. Este es tu primer paso en la sobrecarga de operadores: hacer que tus clases personalizadas funcionen con operadores familiares.

Crearás dos archivos para organizar tu código:

Point.h: Define una clase Point que almacene coordenadas x e y (ambas int). Tu clase debe tener:
- Miembros privados para las coordenadas x e y
- Un constructor que reciba los valores x e y
- Getters getX() y getY() (ambos const)
- Un operador + sobrecargado que sume dos puntos y devuelva un nuevo Point con las coordenadas combinadas
El operador + debe implementarse como una función miembro que reciba otro Point por referencia constante y devuelva un nuevo Point. Márcalo como const ya que no modifica ninguno de los operandos.
main.cpp: Lee cuatro enteros de la entrada (x1, y1, x2, y2 en líneas separadas) que representan dos puntos. Crea dos objetos Point, súmalos usando el operador + y muestra los resultados.
Formato de salida:
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

La idea clave aquí es que p1 + p2 en realidad está llamando a p1.operator+(p2) entre bastidores. Tu operador sobrecargado te permite escribir código intuitivo como Point p3 = p1 + p2; en lugar de algo como Point p3 = p1.add(p2);.

Convierte las cadenas de entrada a enteros usando std::stoi(). No olvides los protectores de inclusión (header guards) en tu archivo de cabecera.

Hoja de referencia

La sobrecarga de operadores permite definir cómo se comportan los operadores como +, - o == con clases personalizadas, permitiendo una sintaxis intuitiva como a + b en lugar de a.add(b).

Para sobrecargar un operador, defina una función utilizando la palabra clave operator seguida del símbolo:

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Sobrecargar el operador +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Uso:

Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;    // Llama a v1.operator+(v2)

Algunos operadores no se pueden sobrecargar: ::, ., ?: y sizeof. No se pueden crear nuevos operadores ni cambiar la precedencia de los operadores.

Los operadores pueden implementarse como funciones miembro o funciones no miembro.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Point.h"

using namespace std;

int main() {
    // Leer la entrada
    string line1, line2, line3, line4;
    getline(cin, line1);
    getline(cin, line2);
    getline(cin, line3);
    getline(cin, line4);

    int x1 = stoi(line1);
    int y1 = stoi(line2);
    int x2 = stoi(line3);
    int y2 = stoi(line4);

    // TODO: Crear dos objetos Point usando los valores de entrada

    // TODO: Sumar los dos puntos usando el operador +

    // TODO: Mostrar los resultados en el formato requerido:
    // Point 1: (<x1>, <y1>)
    // Point 2: (<x2>, <y2>)
    // Suma: (<sum_x>, <sum_y>)

    return 0;
}