Blocchi impl multipli

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

Rust ti consente di suddividere i metodi di una struct in più blocchi impl. Anche se potresti inserire tutto in un unico blocco, separarli può rendere il tuo codice più organizzato e leggibile.

Ecco una struct con le sue funzionalità suddivise in due blocchi di implementazione:

struct BankAccount {
    balance: f64,
}

// Costruttore e operazioni di base
impl BankAccount {
    fn new(initial: f64) -> BankAccount {
        BankAccount { balance: initial }
    }
    
    fn balance(&self) -> f64 {
        self.balance
    }
}

// Metodi per le transazioni
impl BankAccount {
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) {
        self.balance -= amount;
    }
}

Entrambi i blocchi funzionano insieme senza problemi: Rust li tratta come se fossero uno solo. Puoi chiamare qualsiasi metodo, indipendentemente dal blocco in cui è definito:

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

Questo schema diventa particolarmente utile man mano che le tue struct crescono. Potresti raggruppare i costruttori, tenere separati i metodi di sola lettura da quelli che modificano i dati oppure organizzare tutto in base alle funzionalità. Non c’è limite al numero di blocchi impl che una struct può avere.

Sfida

Facile

Crea una struct Player con due campi: name (String) e score (u32).

Organizza i metodi della struct in due blocchi di implementazione separati:

Primo blocco impl: costruttore e query:

new: una funzione associata che accetta un name: String e restituisce un Player con score impostato a 0
get_score: accetta &self e restituisce il punteggio corrente come u32

Secondo blocco impl: modifiche al punteggio:

add_points: accetta &mut self e points: u32, aggiunge i punti al punteggio
reset_score: accetta &mut self e riporta il punteggio a 0

Riceverai tre input:

Prima riga: il nome del giocatore (String)
Seconda riga: i punti da aggiungere nel primo round (u32)
Terza riga: i punti da aggiungere nel secondo round (u32)

Crea un giocatore usando Player::new, aggiungi i punti del primo round, stampa il punteggio, poi azzera il punteggio, aggiungi i punti del secondo round e stampa il punteggio finale.

Formato dell'output previsto:

{score_after_first_round}
{score_after_reset_and_second_round}

Provalo tu

use std::io;

// TODO: Definisci la struct Player con i campi name (String) e score (u32)


// TODO: Primo blocco impl - Costruttore e metodi di consultazione (new, get_score)


// TODO: Secondo blocco impl - Metodi per modificare il punteggio (add_points, reset_score)


fn main() {
    let mut input = String::new();
    
    // Leggi il nome del giocatore
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let name = input.trim().to_string();
    
    // Leggi i punti del primo turno
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_round: u32 = input.trim().parse().expect("Invalid number");
    
    // Leggi i punti del secondo turno
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let second_round: u32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Crea un giocatore usando Player::new
    // TODO: Aggiungi i punti del primo turno e stampa il punteggio
    // TODO: Azzera il punteggio
    // TODO: Aggiungi i punti del secondo turno e stampa il punteggio finale
}