Les traits d'égalité

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 38 sur 61.

Comparer deux instances d’une structure personnalisée avec == ne fonctionne pas par défaut en Rust. Le compilateur ne sait pas comment déterminer si deux structures sont égales. Vous devez le lui indiquer en implémentant le trait PartialEq.

Comme avec Debug et Copy, vous pouvez dériver automatiquement PartialEq :

#[derive(PartialEq)]
struct Coordinate {
    x: i32,
    y: i32,
}

let a = Coordinate { x: 5, y: 10 };
let b = Coordinate { x: 5, y: 10 };
let c = Coordinate { x: 3, y: 7 };

println!("{}", a == b);  // true
println!("{}", a == c);  // false

Lorsqu’il est dérivé, PartialEq compare chaque champ de la structure. Deux instances sont égales uniquement si tous leurs champs correspondants concordent.

Vous rencontrerez également Eq, qui est un trait marqueur indiquant une égalité totale, ce qui signifie que chaque valeur est égale à elle-même. La plupart des types satisfont cette condition, mais les nombres à virgule flottante ne la satisfont pas (car NaN != NaN). Pour les structures comportant des champs entiers, vous pouvez dériver les deux en toute sécurité :

#[derive(PartialEq, Eq)]
struct Coordinate {
    x: i32,
    y: i32,
}

Eq n'a aucune méthode qui lui soit propre. Il indique simplement que le type possède une égalité réflexive. Certaines fonctionnalités de la bibliothèque standard nécessitent Eq en plus de PartialEq ; il est donc courant de dériver les deux ensemble pour les types qui s'y prêtent.

Défi

Facile

Construisons un système de correspondance des couleurs qui montre comment les traits PartialEq et Eq permettent de comparer des instances de structures !

Tu vas créer deux fichiers pour organiser ta logique de comparaison des couleurs :

color.rs : définis une structure Color publique avec trois champs publics : red, green et blue (tous de type u8). Dérive à la fois PartialEq et Eq afin que deux couleurs puissent être comparées à l'aide de ==. Lorsqu'ils sont dérivés, Rust considère que deux couleurs sont égales uniquement si les trois composantes RGB correspondent exactement.
main.rs : importe ton module de couleurs et crée deux instances de Color à l'aide des entrées fournies. Compare-les avec == et affiche si elles correspondent ou non.

Ta sortie doit indiquer si les deux couleurs sont identiques :

Color 1: rgb({r1}, {g1}, {b1})
Color 2: rgb({r2}, {g2}, {b2})
Colors match: {true/false}

Par exemple, avec les entrées 255, 128, 0, 255, 128, 0 :

Color 1: rgb(255, 128, 0)
Color 2: rgb(255, 128, 0)
Colors match: true

Et avec les entrées 100, 100, 100, 200, 200, 200 :

Color 1: rgb(100, 100, 100)
Color 2: rgb(200, 200, 200)
Colors match: false

Tu recevras six entrées : les valeurs RGB de la première couleur (trois valeurs), suivies des valeurs RGB de la seconde couleur (trois valeurs). Analyse chacune d'elles comme un u8.

Essayez vous-même

mod color;

use color::Color;

fn main() {
    // Lire les six valeurs RGB
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let r1: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let g1: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let b1: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let r2: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let g2: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let b2: u8 = input.trim().parse().expect("Invalid input");

    // TODO: Créer deux instances de Color en utilisant les valeurs analysées

    // TODO: Afficher Color 1 au format : Color 1: rgb(r, g, b)

    // TODO: Afficher Color 2 au format : Color 2: rgb(r, g, b)

    // TODO: Compare the two colors using == and print: Colors match: {true/false}
}