Méthodes mutables

Fait partie de la section Object Oriented Programming 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 capables de modifier les champs d'une structure, 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
    }
}

Notez que increment et decrement utilisent &mut self parce qu'ils modifient value, tandis que get utilise &self car 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 vous oubliez le mot-clé mut lors de la création de l'instance, Rust vous empêchera d'appeler toute méthode &mut self sur celle-ci. Cela garantit que vous êtes toujours conscient du moment où vos données pourraient 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, ajoute le montant au solde
withdraw — prend &mut self et un amount: i32, soustrait le montant du solde
get_balance — prend &self et retourne le solde actuel en tant que 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}

Aide-mémoire

Les méthodes qui modifient les champs d'une structure utilisent &mut self (emprunt mutable), tandis que les méthodes qui lisent uniquement les données utilisent &self :

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

Pour appeler des méthodes mutables, l'instance doit être déclarée comme mutable avec let mut :

let mut counter = Counter { value: 0 };

counter.increment();
counter.increment();
println!("{}", counter.get()); // 2

counter.decrement();
println!("{}", counter.get()); // 1

Sans le mot-clé mut sur l'instance, Rust empêchera l'appel de toute méthode &mut self.

Essayez vous-même

use std::io;

// TODO: Définir la structure 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
}