Sobrecarga de operadores de comparación

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 42 de 104.

Los operadores de comparación como ==, !=, <, >, <= y >= te permiten comparar objetos de tus clases personalizadas. Estos operadores devuelven un bool y deberían marcarse como const, ya que no modifican ninguno de los operandos.

class Date {
    int year, month, day;
    
public:
    Date(int y, int m, int d) : year(y), month(m), day(d) {}
    
    bool operator==(const Date& other) const {
        return year == other.year && 
               month == other.month && 
               day == other.day;
    }
    
    bool operator<(const Date& other) const {
        if (year != other.year) return year < other.year;
        if (month != other.month) return month < other.month;
        return day < other.day;
    }
};

Una técnica útil es implementar otros operadores de comparación en términos de los que ya has definido. Una vez que tienes == y <, el resto se deduce de forma natural:

bool operator!=(const Date& other) const {
    return !(*this == other);
}

bool operator>(const Date& other) const {
    return other < *this;
}

bool operator<=(const Date& other) const {
    return !(other < *this);
}

bool operator>=(const Date& other) const {
    return !(*this < other);
}

Este enfoque reduce la duplicación de código y garantiza que todos tus operadores de comparación se comporten de manera coherente. Si más adelante cambias cómo funcionan la igualdad o el operador menor que, los demás operadores se mantienen automáticamente sincronizados.

Desafío

Fácil

Construyamos una clase Version que represente números de versión de software (como 2.1.0 o 3.0.5) y admita los seis operadores de comparación. Este es un caso de uso práctico en el que comparar versiones determina qué software es más reciente, perfecto para practicar la sobrecarga de operadores de comparación.

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

Version.h: Define una clase Version que almacene tres enteros que representan los números de versión major, minor y patch. Tu clase debe admitir:
- Un constructor que acepte valores major, minor y patch
- Getters para cada componente: getMajor(), getMinor(), getPatch() (todos const)
- Los seis operadores de comparación: ==, !=, <, >, <=, >=
- Un método toString() que devuelva la versión como una cadena con el formato "major.minor.patch"
Implementa == y < directamente y, después, define los cuatro operadores restantes en función de estos dos. Para la comparación menor que, compara primero major; después, minor si los valores major son iguales; y, por último, patch si tanto major como minor son iguales. Todos los operadores de comparación deben ser funciones miembro const.
main.cpp: Lee seis enteros de la entrada que representen dos versiones (major1, minor1, patch1, major2, minor2, patch2 en líneas separadas). Crea dos objetos Version y compáralos usando todos tus operadores.
Formato de salida:
```
Version 1: <v1>
Version 2: <v2>
v1 == v2: <true/false>
v1 != v2: <true/false>
v1 < v2: <true/false>
v1 > v2: <true/false>
v1 <= v2: <true/false>
v1 >= v2: <true/false>
```
Imprime true o false (en minúsculas) para cada resultado de comparación.

La técnica clave aquí consiste en implementar los cuatro operadores derivados (!=, >, <=, >=) usando únicamente == y <. Esto reduce la duplicación de código y garantiza que todos los operadores sigan siendo coherentes si alguna vez cambias la lógica de comparación.

Convierte las cadenas de entrada en enteros usando std::stoi(). Usa std::to_string() para construir la cadena de versión. No olvides las protecciones contra inclusiones múltiples en tu archivo de encabezado.

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Lee seis enteros para dos versiones
    string line;
    
    getline(cin, line);
    int major1 = stoi(line);
    
    getline(cin, line);
    int minor1 = stoi(line);
    
    getline(cin, line);
    int patch1 = stoi(line);
    
    getline(cin, line);
    int major2 = stoi(line);
    
    getline(cin, line);
    int minor2 = stoi(line);
    
    getline(cin, line);
    int patch2 = stoi(line);

    // TODO: Crea dos objetos Version
    
    // TODO: Muestra Version 1 y Version 2 usando toString()
    
    // TODO: Compara usando los seis operadores y muestra los resultados
    // Usa "true" o "false" (minúsculas) para cada comparación
    // Formato: "v1 == v2: true" o "v1 == v2: false"
    
    return 0;
}