Méthodes génériques

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

Une structure générique peut contenir n’importe quel type, mais elle n’est pas très utile sans méthodes permettant d’interagir avec ses données. Pour définir des méthodes pour une structure générique, tu as besoin d’une syntaxe spéciale dans le bloc impl.

La clé consiste à déclarer le paramètre générique sur le impl lui-même :

struct Wrapper<T> {
    value: T,
}

impl<T> Wrapper<T> {
    fn get(&self) -> &T {
        &self.value
    }
}

Remarque impl<T> avant Wrapper<T>. Cela indique à Rust que T est un paramètre de type générique pour l’ensemble du bloc d’implémentation. Sans cette déclaration, Rust chercherait un type concret nommé T et ne le trouverait pas.

La méthode get renvoie &T : une référence vers le type que contient le wrapper. Cela fonctionne que T soit un entier, une chaîne de caractères ou tout autre type :

let num_wrapper = Wrapper { value: 100 };
let text_wrapper = Wrapper { value: "Rust" };

println!("{}", num_wrapper.get());  // 100
println!("{}", text_wrapper.get()); // Rust

La même définition de méthode fonctionne pour les deux, car le type générique T s’adapte à chaque type concret lors de la compilation.

Défi

Facile

Étendons ton conteneur générique avec des méthodes ! Tu vas créer une struct Box (à ne pas confondre avec la Box standard de Rust) qui peut contenir n'importe quel type et fournit des méthodes pour interagir avec son contenu.

Tu vas répartir ton code dans deux fichiers :

mybox.rs : définis une struct générique publique appelée MyBox<T>, avec un champ privé contents de type T. Implémente des méthodes pour cette struct :
- Une fonction associée new qui crée une nouvelle MyBox avec la valeur donnée
- Une méthode peek qui renvoie une référence au contenu (en utilisant &self)
- Une méthode replace qui prend une nouvelle valeur et remplace le contenu actuel (en utilisant &mut self)
main.rs : importe ton module et montre les méthodes génériques en action avec différents types. Tu vas créer des boîtes, examiner leur contenu et remplacer des valeurs pour montrer le fonctionnement des méthodes.

N'oublie pas la syntaxe essentielle pour implémenter des méthodes sur une struct générique : tu dois écrire impl<T> avant MyBox<T> pour indiquer à Rust que T est un paramètre générique pour tout le bloc d'implémentation.

Dans ton fichier principal, montre le fonctionnement de ta MyBox en :

Créant une boîte avec un entier (la première entrée, analysée comme un i32)
Examinant son contenu et en affichant la valeur
Remplaçant le contenu par un nouvel entier (la deuxième entrée, analysée comme un i32)
Examinant à nouveau le contenu pour afficher la valeur mise à jour
Créant une deuxième boîte avec une chaîne (la troisième entrée)
Examinant le contenu de la boîte contenant la chaîne

Ta sortie doit respecter ce format :

Integer box contains: {value}
After replace: {value}
String box contains: {value}

Par exemple, avec les entrées 10, 25 et Rust :

Integer box contains: 10
After replace: 25
String box contains: Rust

Tu recevras trois entrées : un entier initial, un entier de remplacement et une chaîne.

Essayez vous-même

mod mybox;

use mybox::MyBox;

fn main() {
    // Lire les entrées
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let initial_int: i32 = input1.trim().parse().expect("Invalid integer");

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

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let string_value = input3.trim().to_string();

    // TODO: Créer une MyBox avec l’entier initial
    
    // TODO: Consulter son contenu et afficher : "Integer box contains: {value}"
    
    // TODO: Remplacer son contenu par l’entier de remplacement
    
    // TODO: Consulter à nouveau son contenu et afficher : "After replace: {value}"
    
    // TODO: Créer une deuxième MyBox avec la valeur de la chaîne
    
    // TODO: Consulter le contenu de la boîte contenant la chaîne et afficher : "String box contains: {value}"
}