Múltiplos Blocos de Implementação

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 5 de 61.

Rust permite dividir os métodos de uma struct em vários blocos impl. Embora tudo pudesse ficar em um único bloco, separá-los pode deixar seu código mais organizado e legível.

Aqui está uma struct com sua funcionalidade dividida em dois blocos de implementação:

struct BankAccount {
    balance: f64,
}

// Construtor e consultas básicas
impl BankAccount {
    fn new(initial: f64) -> BankAccount {
        BankAccount { balance: initial }
    }
    
    fn balance(&self) -> f64 {
        self.balance
    }
}

// Métodos de transação
impl BankAccount {
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) {
        self.balance -= amount;
    }
}

Ambos os blocos funcionam juntos perfeitamente: o Rust os trata como se fossem um só. Você pode chamar qualquer método, independentemente do bloco em que ele foi definido:

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

Esse padrão se torna especialmente útil à medida que suas structs crescem. Você pode agrupar os construtores, manter os métodos somente para leitura separados dos métodos que fazem alterações ou organizar por funcionalidade. Não há limite para a quantidade de blocos impl que uma struct pode ter.

Desafio

Fácil

Crie uma struct Player com dois campos: name (String) e score (u32).

Organize os métodos da struct em dois blocos de implementação separados:

Primeiro bloco impl: construtor e consulta:

new: uma função associada que recebe um name: String e retorna um Player com score definido como 0
get_score: recebe &self e retorna a pontuação atual como u32

Segundo bloco impl: modificações da pontuação:

add_points: recebe &mut self e points: u32, adiciona os pontos à pontuação
reset_score: recebe &mut self e define a pontuação novamente como 0

Você receberá três entradas:

Primeira linha: o nome do jogador (String)
Segunda linha: pontos a adicionar na primeira rodada (u32)
Terceira linha: pontos a adicionar na segunda rodada (u32)

Crie um jogador usando Player::new, adicione os pontos da primeira rodada, imprima a pontuação, depois redefina a pontuação, adicione os pontos da segunda rodada e imprima a pontuação final.

Formato de saída esperado:

{score_after_first_round}
{score_after_reset_and_second_round}

Experimente você mesmo

use std::io;

// TODO: Defina a struct Player com os campos name (String) e score (u32)


// TODO: Primeiro bloco impl - Métodos de construtor e consulta (new, get_score)


// TODO: Segundo bloco impl - Métodos de modificação de pontuação (add_points, reset_score)


fn main() {
    let mut input = String::new();
    
    // Leia o nome do jogador
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let name = input.trim().to_string();
    
    // Leia os pontos da primeira rodada
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_round: u32 = input.trim().parse().expect("Invalid number");
    
    // Leia os pontos da segunda rodada
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let second_round: u32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Crie um jogador usando Player::new
    // TODO: Adicione os pontos da primeira rodada e imprima a pontuação
    // TODO: Resete a pontuação
    // TODO: Adicione os pontos da segunda rodada e imprima a pontuação final
}