La parola chiave public

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

Nella lezione precedente hai imparato a organizzare il codice in file di moduli separati. Tuttavia, se provassi a usare la struct Player da main.rs, incontreresti un errore del compilatore. Questo perché, in un modulo Rust, tutto è privato per impostazione predefinita.

Per rendere gli elementi accessibili dall'esterno del loro modulo, devi contrassegnarli esplicitamente con la parola chiave pub:

// player.rs
pub struct Player {
    pub name: String,
    pub score: u32,
}

impl Player {
    pub fn new(name: String) -> Player {
        Player { name, score: 0 }
    }
}

Nota come pub compaia in più punti: sulla struct stessa, su ogni campo e sul metodo. Ogni elemento ha bisogno della propria dichiarazione di visibilità.

Senza pub sulla struct, gli altri file non possono nemmeno fare riferimento al tipo. Senza pub sui campi, non possono accedere direttamente ai dati. Senza pub sui metodi, non possono chiamarli.

Ora, in main.rs, puoi usare gli elementi pubblici del modulo:

// main.rs
mod player;

use player::Player;

fn main() {
    let p = Player::new(String::from("Alice"));
    println!("{}", p.name);
}

L'istruzione use rende Player disponibile nell'ambito, così non devi scrivere player::Player ogni volta. Questo approccio in cui la privacy è predefinita è intenzionale. Ti incoraggia a riflettere attentamente su quali parti del tuo codice dovrebbero essere esposte al mondo esterno.

Sfida

Facile

Costruiamo un semplice catalogo di prodotti organizzando il codice in due file e rendendo pubblici gli elementi appropriati, in modo che possano essere usati dal programma principale.

Creerai due file:

product.rs: Definisci uno struct Product con due campi: name (String) e price (f64). Aggiungi una funzione associata chiamata new che accetta un nome e un prezzo e restituisce un nuovo Product. Ricorda di contrassegnare lo struct, i suoi campi e il metodo come pubblici, in modo che siano accessibili dall'esterno del modulo.
main.rs: Dichiara il modulo product, importa Product nell'ambito con un'istruzione use, poi crea un prodotto e stampa i suoi dettagli.

Rifletti attentamente su dove ti serve la parola chiave pub: lo struct stesso deve essere visibile, i campi devono essere accessibili in lettura e il metodo costruttore deve poter essere chiamato da main.rs.

L'output deve seguire esattamente questo formato:

Product: {name}, Price: ${price}

Per esempio, se crei un prodotto con nome "Laptop" e prezzo 999.99, l'output sarà:

Product: Laptop, Price: $999.99

Riceverai due valori in input: il nome del prodotto e il prezzo.

Provalo tu

// Dichiara il modulo product
mod product;

// TODO: Porta Product nell'ambito con un'istruzione use

fn main() {
    // Leggi l'input
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut price_input = String::new();
    std::io::stdin().read_line(&mut price_input).expect("Failed to read line");
    let price: f64 = price_input.trim().parse().expect("Failed to parse price");
    
    // TODO: Crea un nuovo Product usando la funzione Product::new
    
    // TODO: Stampa i dettagli del prodotto nel formato:
    // Product: {name}, Price: ${price}
}