Le mot-clé public

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 9 sur 61.

Dans la leçon précédente, tu as appris à organiser le code dans des fichiers de module séparés. Cependant, si tu essayais d’utiliser la structure Player depuis main.rs, tu rencontrerais une erreur de compilation. En effet, tout ce qui se trouve dans un module Rust est privé par défaut.

Pour rendre les éléments accessibles depuis l’extérieur de leur module, vous devez les marquer explicitement avec le mot-clé pub :

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

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

Remarquez comment pub apparaît à plusieurs endroits, sur la structure elle-même, sur chaque champ et sur la méthode. Chaque élément a besoin de sa propre déclaration de visibilité.

Sans pub sur la structure, les autres fichiers ne peuvent même pas nommer le type. Sans pub sur les champs, ils ne peuvent pas accéder directement aux données. Sans pub sur les méthodes, ils ne peuvent pas les appeler.

Maintenant, dans main.rs, vous pouvez utiliser les éléments publics du module :

// main.rs
mod player;

use player::Player;

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

L’instruction use rend Player accessible dans la portée, afin que vous n’ayez pas à écrire player::Player à chaque fois. Cette approche de confidentialité par défaut est intentionnelle. Elle vous encourage à réfléchir attentivement aux parties de votre code qui devraient être exposées au monde extérieur.

Défi

Facile

Construisons un catalogue de produits simple en organisant votre code dans deux fichiers et en rendant publics les bons éléments afin qu’ils puissent être utilisés depuis votre programme principal.

Vous allez créer deux fichiers :

product.rs : définissez une structure Product avec deux champs : name (String) et price (f64). Ajoutez une fonction associée appelée new qui prend un nom et un prix et renvoie un nouveau Product. N’oubliez pas de marquer la structure, ses champs et la méthode comme publics afin qu’ils puissent être accessibles depuis l’extérieur du module.
main.rs : déclarez le module de produit, rendez Product accessible avec une instruction use, puis créez un produit et affichez ses détails.

Réfléchissez attentivement à l’endroit où vous devez utiliser le mot-clé pub : la structure elle-même doit être visible, les champs doivent être accessibles en lecture, et la méthode constructeur doit pouvoir être appelée depuis main.rs.

Votre sortie doit respecter exactement le format suivant :

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

Par exemple, si vous créez un produit nommé "Laptop" au prix de 999.99, la sortie sera :

Product: Laptop, Price: $999.99

Vous recevrez deux entrées : le nom du produit et le prix.

Essayez vous-même

// Déclare le module product
mod product;

// TODO: Mets Product dans la portée avec une instruction use

fn main() {
    // Lit l'entrée
    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: Crée un nouveau Product en utilisant la fonction Product::new
    
    // TODO: Affiche les détails du produit au format :
    // Product: {name}, Price: ${price}
}