Sobrecarga de Operadores de Comparação

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 42 de 104.

Operadores de comparison como ==, !=, <, >, <= e >= permitem comparar objetos de suas classes personalizadas. Esses operadores retornam um bool e devem ser marcados como const, pois não modificam nenhum dos 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;
    }
};

Uma técnica útil é implementar outros operadores de comparação em termos daqueles que você já definiu. Depois que você tiver == e <, os demais seguem naturalmente:

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

Essa abordagem reduz a duplicação de código e garante que todos os seus operadores de comparação se comportem de maneira consistente. Se mais tarde você alterar o funcionamento da igualdade ou do menor que, os outros operadores permanecerão automaticamente sincronizados.

Desafio

Fácil

Vamos criar uma classe Version que representa números de versão de software (como 2.1.0 ou 3.0.5) e oferece suporte a todos os seis operadores de comparação. Este é um caso de uso prático em que comparar versões determina qual software é mais recente — perfeito para praticar a sobrecarga de operadores de comparação.

Você criará dois arquivos para organizar seu código:

Version.h: Defina uma classe Version que armazene três inteiros representando os números de versão major, minor e patch. Sua classe deve oferecer suporte a:
- Um construtor que recebe valores major, minor e patch
- Getters para cada componente: getMajor(), getMinor(), getPatch() (todos const)
- Todos os seis operadores de comparação: ==, !=, <, >, <=, >=
- Um método toString() que retorna a versão como uma string no formato "major.minor.patch"
Implemente == e < diretamente e, em seguida, defina os outros quatro operadores em termos desses dois. Para a comparação menor que, compare primeiro major, depois minor se os valores major forem iguais e, por fim, patch se tanto major quanto minor forem iguais. Todos os operadores de comparação devem ser funções-membro const.
main.cpp: Leia seis inteiros da entrada representando duas versões (major1, minor1, patch1, major2, minor2, patch2 em linhas separadas). Crie dois objetos Version e compare-os usando todos os seus operadores.
Formato da saída:
```
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>
```
Imprima true ou false (em lowercase) para cada resultado da comparação.

A técnica principal aqui é implementar os quatro operadores derivados (!=, >, <=, >=) usando apenas == e <. Isso reduz a duplicação de código e garante que todos os operadores permaneçam consistentes caso você altere a lógica de comparação.

Converta as strings de entrada em inteiros usando std::stoi(). Use std::to_string() para construir a string da versão. Não se esqueça dos header guards no seu arquivo de cabeçalho.

Experimente você mesmo

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

using namespace std;

int main() {
    // Leia seis inteiros para duas versões
    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: Crie dois objetos Version
    
    // TODO: Exiba Version 1 e Version 2 usando toString()
    
    // TODO: Compare usando todos os seis operadores e exiba os resultados
    // Use "true" ou "false" (minúsculas) para cada comparação
    // Formato: "v1 == v2: true" ou "v1 == v2: false"
    
    return 0;
}