Surcharge des opérateurs de comparaison

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 42 sur 104.

Les Comparison operators comme ==, !=, <, >, <= et >= vous permettent de comparer des objects de vos classes personnalisées. Ces operators renvoient un bool et devraient être marqués const puisqu’ils ne modifient aucun des deux opérandes.

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

Une technique utile consiste à implémenter les autres opérateurs de comparaison en fonction de ceux que vous avez déjà définis. Une fois que vous avez == et <, les autres suivent naturellement :

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

Cette approche réduit la duplication du code et garantit que tous vos opérateurs de comparaison se comportent de manière cohérente. Si vous modifiez ultérieurement le fonctionnement de l’égalité ou de l’infériorité, les autres opérateurs restent automatiquement synchronisés.

Défi

Facile

Construisons une classe Version qui représente des numéros de version logicielle (comme 2.1.0 ou 3.0.5) et prend en charge les six opérateurs de comparaison. Il s'agit d'un cas d'utilisation pratique où la comparaison des versions permet de déterminer quel logiciel est le plus récent — parfait pour s'exercer à la surcharge des opérateurs de comparaison.

Vous allez créer deux fichiers pour organiser votre code :

Version.h : définissez une classe Version qui stocke trois entiers représentant les numéros de version major, minor et patch. Votre classe doit prendre en charge :
- Un constructeur qui accepte les valeurs major, minor et patch
- Des accesseurs pour chaque composant : getMajor(), getMinor(), getPatch() (tous const)
- Les six opérateurs de comparaison : ==, !=, <, >, <=, >=
- Une méthode toString() qui renvoie la version sous forme de chaîne au format "major.minor.patch"
Implémentez directement == et <, puis définissez les quatre opérateurs restants à partir de ces deux opérateurs. Pour la comparaison inférieure, comparez d'abord major, puis minor si les valeurs major sont égales, et enfin patch si major et minor sont tous deux égaux. Tous les opérateurs de comparaison doivent être des fonctions membres const.
main.cpp : lisez six entiers en entrée représentant deux versions (major1, minor1, patch1, major2, minor2, patch2 sur des lignes séparées). Créez deux objets Version et comparez-les à l'aide de tous vos opérateurs.
Format de sortie :
```
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>
```
Affichez true ou false (en minuscules) pour chaque résultat de comparaison.

La technique clé consiste ici à implémenter les quatre opérateurs dérivés (!=, >, <=, >=) en utilisant uniquement == et <. Cela réduit la duplication du code et garantit la cohérence de tous les opérateurs si vous modifiez un jour la logique de comparaison.

Convertissez les chaînes d'entrée en entiers à l'aide de std::stoi(). Utilisez std::to_string() pour construire la chaîne de version. N'oubliez pas les gardes d'inclusion dans votre fichier d'en-tête.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire six entiers pour deux versions
    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: Créer deux objets Version
    
    // TODO: Afficher Version 1 et Version 2 en utilisant toString()
    
    // TODO: Comparer en utilisant les six opérateurs et afficher les résultats
    // Utiliser "true" ou "false" (minuscules) pour chaque comparaison
    // Format : "v1 == v2: true" ou "v1 == v2: false"
    
    return 0;
}