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 operadores como +, - o == cuando se utilizan con tus clases personalizadas. En lugar de llamar a métodos como a.add(b), puedes escribir la forma más intuitiva a + b.

En C++, los operadores son esencialmente funciones con nombres especiales. Para sobrecargar un operador, 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) {}
    
    // Sobrecarga el operador +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Ahora puedes Add 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 se pueden sobrecargar. El operador de resolución de ámbito ::, el acceso a miembros ., el operador ternario ?: y sizeof no se pueden sobrecargar. Además, no puedes crear operadores nuevos ni cambiar la precedencia de un operador: * siempre se evaluará antes que +.

Los operadores se pueden implementar 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

Construyamos una clase Point que represente una coordenada 2D y permita sumar dos puntos usando el operador +. Este es tu primer paso hacia la sobrecarga de operadores, haciendo que tus clases personalizadas funcionen con operadores conocidos.

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

Point.h: Define una clase Point que almacene las 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
- Los 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 representen 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 llama a p1.operator+(p2) internamente. 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 en enteros usando std::stoi(). No olvides las guardas de inclusión en tu archivo de encabezado.

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: Crea dos objetos Point usando los valores de entrada

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

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

    return 0;
}