Récapitulatif - Afficheur générique

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

Défi

Facile

Construisons un système d’annonces flexible qui démontre la puissance des contraintes de traits ! Tu vas créer un trait Printable et une fonction générique capable d’annoncer tout type implémentant ce trait : cela montre comment les génériques et les traits fonctionnent ensemble pour créer du code réutilisable et sûr du point de vue des types.

Tu organiseras ton code sur deux fichiers :

printable.rs : définis un trait public Printable avec une méthode print_info qui prend &self et renvoie une String. Crée ensuite une fonction générique publique appelée announce qui accepte tout type T implémentant Printable. Cette fonction doit afficher Announcement: {info}, où {info} est le résultat de l’appel de print_info() sur l’élément.
main.rs : crée deux structures publiques qui implémentent Printable :
- Person : avec un champ public name (String). Son print_info doit renvoyer Person: {name}
- Product : avec les champs publics name (String) et price (f64). Son print_info doit renvoyer Product: {name} - ${price}
Importe ton module printable, utilise les entrées pour créer une instance de Person et une instance de Product, puis appelle announce avec chacune afin de démontrer que ta fonction générique fonctionne avec tout type Printable.

La beauté de cette conception est que announce ne se soucie pas de recevoir un Person, un Product ou tout type futur. Il suffit que le type puisse fournir des informations grâce à print_info(). La contrainte de trait garantit cela lors de la compilation.

Ta sortie doit afficher les deux annonces :

Announcement: Person: {name}
Announcement: Product: {product_name} - ${price}

Par exemple, avec les entrées Alice, Laptop et 999.99 :

Announcement: Person: Alice
Announcement: Product: Laptop - $999.99

Tu recevras trois entrées : le nom de la personne, le nom du produit et le prix du produit (à analyser comme un f64).

Essayez vous-même

mod printable;

use printable::{Printable, announce};

// TODO: Définir une struct publique Person avec un champ name public (String)
// Implémenter le trait Printable pour Person
// print_info doit retourner "Person: {name}"

// TODO: Définir une struct publique Product avec des champs publics name (String) et price (f64)
// Implémenter le trait Printable pour Product
// print_info doit retourner "Product: {name} - ${price}"

fn main() {
    // Lire les entrées
    let mut person_name = String::new();
    std::io::stdin().read_line(&mut person_name).expect("Failed to read line");
    let person_name = person_name.trim().to_string();

    let mut product_name = String::new();
    std::io::stdin().read_line(&mut product_name).expect("Failed to read line");
    let product_name = product_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éer une instance de Person avec person_name

    // TODO: Créer une instance de Product avec product_name et price

    // TODO: Appeler announce avec le Person

    // TODO: Appeler announce avec le Product
}