Gettery

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

Pola prywatne sprawiają, że zewnętrzny kod nie może bezpośrednio uzyskać dostępu do danych struktury. Czasami jednak trzeba umożliwić innym odczytanie danych bez dawania im możliwości ich zmiany. Właśnie do tego służą metody pobierające.

Getter to po prostu publiczna metoda, która zwraca referencję do prywatnego pola:

// wallet.rs
pub struct Wallet {
    balance: f64,
}

impl Wallet {
    pub fn new(initial: f64) -> Wallet {
        Wallet { balance: initial }
    }
    
    pub fn balance(&self) -> f64 {
        self.balance
    }
}

Metoda balance() przyjmuje &self (dostęp tylko do odczytu) i zwraca wartość prywatnego pola. W Rust metody pobierające dane są zazwyczaj nazywane tak samo jak samo pole: nie trzeba dodawać prefiksu get_.

Teraz zewnętrzny kod może odczytać saldo za pomocą metody:

// main.rs
mod wallet;
use wallet::Wallet;

fn main() {
    let w = Wallet::new(100.0);
    println!("Balance: {}", w.balance());  // Działa!
}

W przypadku pól zawierających posiadane dane, takich jak String, często zwraca się referencję, aby uniknąć niepotrzebnego kopiowania:

pub fn name(&self) -> &String {
    &self.name
}

Gettery zapewniają kontrolowany dostęp do odczytu, jednocześnie chroniąc samo pole. Struktura nadal zarządza swoimi danymi: zewnętrzny kod może je odczytywać, ale nie może ich modyfikować.

Wyzwanie

Łatwy

Zbudujmy system profili użytkowników, który pokazuje, jak metody odczytujące zapewniają kontrolowany dostęp do odczytu prywatnych danych.

Utworzysz dwa pliki, aby uporządkować swój kod:

profile.rs: Zdefiniuj strukturę UserProfile z dwoma prywatnymi polami: username (String) i age (u32). Sama struktura powinna być publiczna, ale pola powinny pozostać prywatne. Zaimplementuj publiczny konstruktor new, który przyjmuje nazwę użytkownika i wiek. Następnie dodaj dwie metody odczytujące:
- username: zwraca referencję do nazwy użytkownika (&String)
- age: zwraca wartość wieku (u32)
main.rs: Wczytaj swój moduł profilu, utwórz obiekt UserProfile i użyj metod odczytujących, aby wyświetlić informacje o użytkowniku.

Pamiętaj, że metody odczytujące w Rust zazwyczaj nazywa się tak samo jak samo pole: prefiks get_ nie jest potrzebny. W przypadku pól typu String zwracaj referencję, aby uniknąć niepotrzebnego kopiowania.

Wynik powinien mieć dokładnie taki format:

Username: {username}
Age: {age}

Na przykład, jeśli utworzysz profil z nazwą użytkownika "alice" i wiekiem 25, wynikiem będzie:

Username: alice
Age: 25

Otrzymasz dwa dane wejściowe: nazwę użytkownika i wiek.

Spróbuj swoich sił

mod profile;

use profile::UserProfile;

fn main() {
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let username = input1.trim().to_string();

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let age: u32 = input2.trim().parse().expect("Failed to parse age");

    // TODO: Utwórz UserProfile za pomocą konstruktora

    // TODO: Użyj metod getter, aby wyświetlić nazwę użytkownika i wiek
    // Format:
    // Nazwa użytkownika: {username}
    // Wiek: {age}
}