Getter

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

Con i campi privati, il codice esterno non può accedere direttamente ai dati della tua struct. Ma a volte devi permettere agli altri di leggere i dati senza dar loro la possibilità di modificarli. È qui che entrano in gioco i metodi getter.

Un getter è semplicemente un metodo pubblico che restituisce un riferimento a un campo privato:

// 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
    }
}

Il metodo balance() prende &self (accesso in sola lettura) e restituisce il valore del campo privato. In Rust, i getter prendono solitamente il nome del campo stesso: non è necessario il prefisso get_.

Ora il codice esterno può leggere il saldo tramite il metodo:

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

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

Per i campi che contengono dati posseduti, come String, spesso restituirai un riferimento per evitare copie non necessarie:

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

I getter ti offrono un accesso in lettura controllato, mantenendo protetto il campo stesso. La struct mantiene il controllo sui propri dati: il codice esterno può guardare, ma non può toccare.

Sfida

Facile

Costruiamo un sistema di profili utente che mostri come i metodi getter forniscano un accesso in lettura controllato ai dati privati.

Creerai due file per organizzare il codice:

profile.rs: definisci una struct UserProfile con due campi privati: username (String) e age (u32). La struct stessa deve essere pubblica, ma i campi devono rimanere privati. Implementa un costruttore pubblico new che accetti un nome utente e un'età. Poi aggiungi due metodi getter:
- username: restituisce un riferimento al nome utente (&String)
- age: restituisce il valore dell'età (u32)
main.rs: importa il modulo del profilo, crea un UserProfile e usa i metodi getter per stampare le informazioni dell'utente.

Ricorda che in Rust i getter prendono in genere il nome del campo stesso: non serve il prefisso get_. Per i campi String, restituisci un riferimento per evitare copie non necessarie.

L'output deve seguire esattamente questo formato:

Username: {username}
Age: {age}

Per esempio, se crei un profilo con il nome utente "alice" e l'età 25, l'output sarà:

Username: alice
Age: 25

Riceverai due input: il nome utente e l'età.

Provalo tu

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: Crea un UserProfile usando il costruttore

    // TODO: Usa i metodi getter per stampare il nome utente e l'età
    // Formato:
    // Nome utente: {username}
    // Età: {age}
}