Metodi mutabili

Fa parte della sezione Programmazione orientata agli oggetti del percorso Rust di Coddy. Lezione 3 di 61.

A volte i metodi devono fare più che limitarsi a leggere i dati. Devono modificarli. Per creare metodi che possono modificare i campi di una struct, usiamo &mut self invece di &self.

La parola chiave mut indica un prestito mutabile, dando al metodo il permesso di modificare lo stato interno dell'istanza:

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

Nota che increment e decrement usano &mut self perché modificano value, mentre get usa &self perché legge soltanto i dati.

Quando chiami metodi mutabili, l’istanza stessa deve essere dichiarata mutabile:

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

Se dimentichi la parola chiave mut quando crei l’istanza, Rust ti impedirà di chiamare su di essa qualsiasi metodo &mut self. In questo modo ti assicuri di sapere sempre quando i tuoi dati potrebbero cambiare.

Sfida

Facile

Crea una struct BankAccount con un singolo campo: balance (i32).

Aggiungi un blocco di implementazione per BankAccount con tre metodi:

deposit: riceve &mut self e un amount: i32, aggiunge l'importo al saldo
withdraw: riceve &mut self e un amount: i32, sottrae l'importo dal saldo
get_balance: riceve &self e restituisce il saldo corrente come i32

Riceverai tre input:

Prima riga: il saldo iniziale (i32)
Seconda riga: l'importo del deposito (i32)
Terza riga: l'importo del prelievo (i32)

Crea un'istanza mutabile di BankAccount con il saldo iniziale, quindi deposita l'importo indicato, preleva l'importo indicato e stampa il saldo finale.

Formato dell'output previsto:

{final_balance}

Provalo tu

use std::io;

// TODO: Definisci qui la struct BankAccount


// TODO: Aggiungi il blocco di implementazione per BankAccount con i metodi deposit, withdraw e get_balance


fn main() {
    let mut input = String::new();
    
    // Leggi il saldo iniziale
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let initial_balance: i32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    
    // Leggi l'importo del deposito
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let deposit_amount: i32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    
    // Leggi l'importo del prelievo
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let withdraw_amount: i32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Crea un'istanza mutabile di BankAccount con initial_balance
    // TODO: Chiama deposit con deposit_amount
    // TODO: Chiama withdraw con withdraw_amount
    // TODO: Stampa il saldo finale usando get_balance
}