Blocs d'implémentation multiples

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

Rust vous permet de répartir les méthodes d’une structure sur plusieurs blocs impl. Bien que tout puisse être placé dans un seul bloc, les séparer peut rendre votre code plus organisé et plus lisible.

Voici une structure dont les fonctionnalités sont réparties entre deux blocs d’implémentation :

struct BankAccount {
    balance: f64,
}

// Constructeur et requêtes de base
impl BankAccount {
    fn new(initial: f64) -> BankAccount {
        BankAccount { balance: initial }
    }
    
    fn balance(&self) -> f64 {
        self.balance
    }
}

// Méthodes de transaction
impl BankAccount {
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) {
        self.balance -= amount;
    }
}

Les deux blocs fonctionnent ensemble de manière transparente : Rust les traite comme s’il n’y en avait qu’un. Vous pouvez appeler n’importe quelle méthode, quel que soit le bloc dans lequel elle est définie :

fn main() {
    let mut account = BankAccount::new(100.0);
    account.deposit(50.0);
    println!("{}", account.balance()); // 150
}

Ce modèle devient particulièrement utile à mesure que vos structures se développent. Vous pouvez regrouper les constructeurs, séparer les méthodes en lecture seule des méthodes mutantes, ou organiser le tout par fonctionnalité. Le nombre de blocs impl qu’une structure peut posséder n’est pas limité.

Défi

Facile

Créez une structure Player avec deux champs : name (String) et score (u32).

Organisez les méthodes de la structure dans deux blocs d’implémentation distincts :

Premier bloc impl : constructeur et requête :

new : une fonction associée qui prend un name: String et renvoie un Player avec score défini à 0
get_score : prend &self et renvoie le score actuel sous forme de u32

Deuxième bloc impl : modifications du score :

add_points : prend &mut self et points: u32, puis ajoute les points au score
reset_score : prend &mut self et réinitialise le score à 0

Vous recevrez trois entrées :

Première ligne : le nom du joueur (String)
Deuxième ligne : les points à ajouter lors de la première manche (u32)
Troisième ligne : les points à ajouter lors de la deuxième manche (u32)

Créez un joueur à l’aide de Player::new, ajoutez les points de la première manche, affichez le score, puis réinitialisez le score, ajoutez les points de la deuxième manche et affichez le score final.

Format de sortie attendu :

{score_after_first_round}
{score_after_reset_and_second_round}

Essayez vous-même

use std::io;

// TODO: Définir la structure Player avec les champs name (String) et score (u32)


// TODO: Premier bloc impl - Méthodes de construction et de requête (new, get_score)


// TODO: Deuxième bloc impl - Méthodes de modification du score (add_points, reset_score)


fn main() {
    let mut input = String::new();
    
    // Lire le nom du joueur
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let name = input.trim().to_string();
    
    // Lire les points de la première manche
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_round: u32 = input.trim().parse().expect("Invalid number");
    
    // Lire les points de la deuxième manche
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let second_round: u32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Créer un joueur en utilisant Player::new
    // TODO: Ajouter les points de la première manche et afficher le score
    // TODO: Réinitialiser le score
    // TODO: Ajouter les points de la deuxième manche et afficher le score final
}