Múltiples Bloques de Implementación

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 5 de 61.

Rust te permite dividir los métodos de una estructura entre varios bloques impl. Aunque todo podría ir en un solo bloque, separarlos puede hacer que tu código esté más organizado y sea más fácil de leer.

Aquí tienes una estructura con su funcionalidad dividida en dos bloques de implementación:

struct BankAccount {
    balance: f64,
}

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

// Métodos de transacción
impl BankAccount {
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) {
        self.balance -= amount;
    }
}

Ambos bloques funcionan juntos sin problemas: Rust los trata como si fueran uno solo. Puedes llamar a cualquier método independientemente del bloque en el que esté definido:

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

Este patrón se vuelve especialmente útil a medida que tus estructuras crecen. Podrías agrupar los constructores, mantener los métodos de solo lectura separados de los mutantes u organizar por funcionalidad. No hay límite para la cantidad de bloques impl que puede tener una estructura.

Desafío

Fácil

Crea una estructura Player con dos campos: name (String) y score (u32).

Organiza los métodos de la estructura en dos bloques de implementación separados:

Primer bloque impl: constructor y consulta:

new: una función asociada que recibe un name: String y devuelve un Player con score establecido en 0
get_score: recibe &self y devuelve la puntuación actual como u32

Segundo bloque impl: modificaciones de la puntuación:

add_points: recibe &mut self y points: u32, y suma los puntos a la puntuación
reset_score: recibe &mut self y vuelve a establecer la puntuación en 0

Recibirás tres entradas:

Primera línea: el nombre del jugador (String)
Segunda línea: puntos que se añadirán en la primera ronda (u32)
Tercera línea: puntos que se añadirán en la segunda ronda (u32)

Crea un jugador usando Player::new, añade los puntos de la primera ronda, imprime la puntuación, después reinicia la puntuación, añade los puntos de la segunda ronda e imprime la puntuación final.

Formato de salida esperado:

{score_after_first_round}
{score_after_reset_and_second_round}

Pruébalo tú mismo

use std::io;

// TODO: Define la struct Player con los campos name (String) y score (u32)


// TODO: Primer bloque impl - Métodos de constructor y consulta (new, get_score)


// TODO: Segundo bloque impl - Métodos de modificación de puntuación (add_points, reset_score)


fn main() {
    let mut input = String::new();
    
    // Lee el nombre del jugador
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let name = input.trim().to_string();
    
    // Lee los puntos de la primera ronda
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_round: u32 = input.trim().parse().expect("Invalid number");
    
    // Lee los puntos de la segunda ronda
    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 jugador usando Player::new
    // TODO: Añade los puntos de la primera ronda e imprime la puntuación
    // TODO: Reinicia la puntuación
    // TODO: Añade los puntos de la segunda ronda e imprime la puntuación final
}