Wiele bloków implementacji

Część sekcji Programowanie obiektowe ścieżki Rust w Coddy. Lekcja 5 z 61.

W Rust możesz podzielić metody struktury między kilka bloków impl. Chociaż wszystko mogłoby znaleźć się w jednym bloku, rozdzielenie metod może sprawić, że Twój kod będzie bardziej uporządkowany i czytelny.

Oto struktura, której funkcjonalność jest podzielona na dwa bloki implementacji:

struct BankAccount {
    balance: f64,
}

// Konstruktor i podstawowe zapytania
impl BankAccount {
    fn new(initial: f64) -> BankAccount {
        BankAccount { balance: initial }
    }
    
    fn balance(&self) -> f64 {
        self.balance
    }
}

// Metody transakcyjne
impl BankAccount {
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) {
        self.balance -= amount;
    }
}

Oba bloki współpracują ze sobą bezproblemowo: Rust traktuje je tak, jakby stanowiły jeden blok. Możesz wywołać dowolną metodę, niezależnie od tego, w którym bloku została zdefiniowana:

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

Ten wzorzec staje się szczególnie przydatny, gdy Twoje struktury się rozrastają. Możesz grupować konstruktory, oddzielać metody tylko do odczytu od metod modyfikujących albo organizować je według funkcji. Nie ma limitu liczby bloków impl, które może mieć struktura.

Wyzwanie

Łatwy

Utwórz strukturę Player z dwoma polami: name (String) i score (u32).

Rozmieść metody struktury w dwóch osobnych blokach implementacji:

Pierwszy blok impl: konstruktor i metoda pobierająca dane:

new: funkcja skojarzona, która przyjmuje name: String i zwraca Player z wartością score ustawioną na 0
get_score: przyjmuje &self i zwraca bieżący wynik jako u32

Drugi blok impl: modyfikowanie wyniku:

add_points: przyjmuje &mut self i points: u32, dodaje punkty do wyniku
reset_score: przyjmuje &mut self i ustawia wynik z powrotem na 0

Otrzymasz trzy dane wejściowe:

Pierwszy wiersz: imię gracza (String)
Drugi wiersz: punkty do dodania w pierwszej rundzie (u32)
Trzeci wiersz: punkty do dodania w drugiej rundzie (u32)

Utwórz gracza za pomocą Player::new, dodaj punkty z pierwszej rundy, wypisz wynik, a następnie wyzeruj wynik, dodaj punkty z drugiej rundy i wypisz wynik końcowy.

Oczekiwany format wyjścia:

{score_after_first_round}
{score_after_reset_and_second_round}

Spróbuj swoich sił

use std::io;

// TODO: Zdefiniuj strukturę Player z polami name (String) i score (u32)


// TODO: Pierwszy blok impl — konstruktor i metody odczytu (new, get_score)


// TODO: Drugi blok impl — metody modyfikacji wyniku (add_points, reset_score)


fn main() {
    let mut input = String::new();
    
    // Wczytaj imię gracza
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let name = input.trim().to_string();
    
    // Wczytaj punkty z pierwszej rundy
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_round: u32 = input.trim().parse().expect("Invalid number");
    
    // Wczytaj punkty z drugiej rundy
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let second_round: u32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Utwórz gracza za pomocą Player::new
    // TODO: Dodaj punkty z pierwszej rundy i wyświetl wynik
    // TODO: Wyzeruj wynik
    // TODO: Dodaj punkty z drugiej rundy i wyświetl wynik końcowy
}