Méthodes mutables

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

Parfois, les méthodes doivent faire plus que simplement lire des données. Elles doivent les modifier. Pour créer des méthodes qui peuvent modifier les champs d’un struct, nous utilisons &mut self au lieu de &self.

Le mot-clé mut indique un emprunt mutable, donnant à la méthode la permission de modifier l’état interne de l’instance :

struct Counter {
    value: i32,
}

impl Counter {
    fn increment(&mut self) {
        self.value += 1;
    }
    
    fn decrement(&mut self) {
        self.value -= 1;
    }
    
    fn get(&self) -> i32 {
        self.value
    }
}

Remarquez que increment et decrement utilisent &mut self parce qu’ils modifient value, tandis que get utilise &self puisqu’il ne fait que lire les données.

Lors de l’appel de méthodes mutables, l’instance elle-même doit être déclarée comme mutable :

fn main() {
    let mut counter = Counter { value: 0 };
    
    counter.increment();
    counter.increment();
    println!("{}", counter.get()); // 2
    
    counter.decrement();
    println!("{}", counter.get()); // 1
}

Si tu oublies le mot-clé mut lors de la création de l’instance, Rust t’empêchera d’appeler des méthodes &mut self sur celle-ci. Cela garantit que tu es toujours conscient lorsque tes données sont susceptibles de changer.

Défi

Facile

Créez une structure BankAccount avec un seul champ : balance (i32).

Ajoutez un bloc d’implémentation pour BankAccount avec trois méthodes :

deposit : prend &mut self et un amount: i32, puis ajoute le montant au solde
withdraw : prend &mut self et un amount: i32, puis soustrait le montant du solde
get_balance : prend &self et renvoie le solde actuel sous forme de i32

Vous recevrez trois entrées :

Première ligne : le solde initial (i32)
Deuxième ligne : le montant du dépôt (i32)
Troisième ligne : le montant du retrait (i32)

Créez une instance mutable de BankAccount avec le solde initial, puis déposez le montant donné, retirez le montant donné et affichez le solde final.

Format de sortie attendu :

{final_balance}

Essayez vous-même

use std::io;

// TODO: Définir la struct BankAccount ici


// TODO: Ajouter le bloc d'implémentation pour BankAccount avec les méthodes deposit, withdraw et get_balance


fn main() {
    let mut input = String::new();
    
    // Lire le solde initial
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let initial_balance: i32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    
    // Lire le montant du dépôt
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let deposit_amount: i32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    
    // Lire le montant du retrait
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let withdraw_amount: i32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Créer une instance mutable de BankAccount avec initial_balance
    // TODO: Appeler deposit avec deposit_amount
    // TODO: Appeler withdraw avec withdraw_amount
    // TODO: Afficher le solde final en utilisant get_balance
}