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 ==, !=, <code><, , <=, y >= le permiten comparar objetos de sus clases personalizadas. Estos operadores devuelven un bool y deben 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 <code><, el resto surge 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 consistente. Si más adelante cambias cómo funciona la igualdad o el menor que, los demás operadores se mantendrán sincronizados automáticamente.

Desafío

Fácil

Vamos a construir una clase Version que represente números de versión de software (como 2.1.0 o 3.0.5) y que admita los seis operadores de comparación. Este es un caso de uso práctico donde comparar versiones determina qué software es más reciente, lo cual es 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 representen los números de versión major, minor y patch. Tu clase debe admitir:
- Un constructor que reciba los valores de 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 en el formato "major.minor.patch"
Implementa == y < directamente, luego define los cuatro operadores restantes en términos de estos dos. Para la comparación "menor que", compara primero major, luego minor si los majors son iguales, y luego 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 representan 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í es implementar los cuatro operadores derivados (!=, >, <=, >=) utilizando solo == y <. Esto reduce la duplicación de código y garantiza que todos los operadores se mantengan consistentes si alguna vez cambias la lógica de comparación.

Convierte las cadenas de entrada a enteros usando std::stoi(). Usa std::to_string() para construir la cadena de la versión. No olvides los header guards en tu archivo de cabecera.

Hoja de referencia

Los operadores de comparación (==, !=, <code><, , <=, >=) le permiten comparar objetos de clases personalizadas. Estos operadores devuelven un bool y deben 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;
    }
};

Implemente otros operadores de comparación en términos de == y <code>< para reducir la duplicación de código y garantizar la consistencia:

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);
}

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 la Version 1 y la Version 2 usando toString()
    
    // TODO: Compara usando los seis operadores y muestra los resultados
    // Usa "true" o "false" (en minúsculas) para cada comparación
    // Formato: "v1 == v2: true" o "v1 == v2: false"
    
    return 0;
}