Getters

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

Avec des champs privés, le code externe ne peut pas accéder directement aux données de votre structure. Mais vous devez parfois permettre à d’autres de lire les données sans leur donner la possibilité de les modifier. C’est là que les méthodes getter interviennent.

Un getter est simplement une méthode publique qui renvoie une référence vers un champ privé :

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

La méthode balance() prend &self (accès en lecture seule) et renvoie la valeur du champ privé. En Rust, les accesseurs portent généralement le nom du champ lui-même : aucun préfixe get_ n’est nécessaire.

Désormais, le code externe peut lire le solde via la méthode :

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

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

Pour les champs contenant des données possédées comme String, vous retournerez souvent une référence afin d’éviter les copies inutiles :

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

Les getters vous donnent un accès en lecture contrôlé tout en gardant le champ lui-même protégé. La structure reste responsable de ses données : le code externe peut les consulter, mais ne peut pas les modifier.

Défi

Facile

Construisons un système de profil utilisateur qui montre comment les méthodes getter permettent un accès en lecture contrôlé aux données privées.

Vous allez créer deux fichiers pour organiser votre code :

profile.rs : Définissez une structure UserProfile avec deux champs privés : username (String) et age (u32). La structure elle-même doit être publique, mais les champs doivent rester privés. Implémentez un constructeur public new qui prend un nom d’utilisateur et un âge. Ajoutez ensuite deux méthodes getter :
- username : renvoie une référence vers le nom d’utilisateur (&String)
- age : renvoie la valeur de l’âge (u32)
main.rs : Importez votre module de profil, créez un UserProfile et utilisez les méthodes getter pour afficher les informations de l’utilisateur.

Souvenez-vous qu’en Rust, les getters sont généralement nommés d’après le champ lui-même : aucun préfixe get_ n’est nécessaire. Pour les champs de type String, renvoyez une référence afin d’éviter les copies inutiles.

Votre sortie doit suivre exactement ce format :

Username: {username}
Age: {age}

Par exemple, si vous créez un profil avec le nom d’utilisateur "alice" et l’âge 25, la sortie serait :

Username: alice
Age: 25

Vous recevrez deux entrées : le nom d’utilisateur et l’âge.

Essayez vous-même

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: Créer un UserProfile en utilisant le constructeur

    // TODO: Utiliser les méthodes getter pour afficher le username et l'âge
    // Format :
    // Username: {username}
    // Age: {age}
}