Récapitulatif - Afficheur générique

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy — leçon 44 sur 61.

Défi

Facile

Construisons un système d'annonce flexible qui démontre la puissance des bornes de traits (trait bounds) ! Vous allez créer un trait Printable et une fonction générique capable d'annoncer n'importe quel type implémentant ce trait, illustrant ainsi comment les génériques et les traits collaborent pour créer un code réutilisable et sûr au niveau des types.

Vous organiserez votre code sur deux fichiers :

printable.rs : Définissez un trait public Printable avec une méthode print_info qui prend &self et retourne un String. Créez ensuite une fonction générique publique nommée announce qui accepte n'importe quel type T implémentant Printable. Cette fonction doit afficher Announcement: {info} où {info} est le résultat de l'appel à print_info() sur l'élément.
main.rs : Créez deux structures publiques qui implémentent Printable :
- Person — avec un champ public name (String). Sa méthode print_info doit retourner Person: {name}
- Product — avec des champs publics name (String) et price (f64). Sa méthode print_info doit retourner Product: {name} - ${price}
Importez votre module printable, utilisez les entrées pour créer une Person et un Product, puis appelez announce avec chacun d'eux pour démontrer que votre fonction générique fonctionne avec n'importe quel type Printable.

La beauté de cette conception est que announce ne se soucie pas de savoir s'il reçoit une Person, un Product ou tout autre type futur — il exige seulement que le type puisse fournir des informations via print_info(). La borne de trait garantit cela au moment de la compilation.

Votre sortie devrait 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

Vous recevrez 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 public name (String)
// Implémenter le trait Printable pour Person
// print_info doit retourner "Person: {name}"

// TODO: Définir une struct publique Product avec les 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 la Person

    // TODO: Appeler announce avec le Product
}