Le trait Debug

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

La bibliothèque standard de Rust est accompagnée de nombreux traits prédéfinis qui fournissent des fonctionnalités courantes. L’un des plus utiles pour le développement est le trait Debug, qui vous permet d’afficher le contenu d’une structure pour l’inspecter.

Si tu essaies d’afficher directement une structure personnalisée, Rust ne saura pas comment l’afficher :

struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // Erreur ! Debug non implémenté

Le formateur {:?} nécessite le trait Debug. Plutôt que de l’implémenter manuellement, Rust fournit un raccourci : l’attribut #[derive]. Place-le directement au-dessus de la définition de ta structure :

#[derive(Debug)]
struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // Player { name: "Alice", score: 100 }

L’attribut #[derive(Debug)] indique au compilateur de générer automatiquement l’implémentation de Debug. Cela fonctionne tant que tous les champs de votre struct implémentent également Debug (ce que font la plupart des types standard).

Pour obtenir une sortie plus lisible avec des structures imbriquées, utilisez {:#?} pour un affichage formaté :

println!("{:#?}", p);
// Player {
//     name: "Alice",
//     score: 100,
// }

Dériver Debug est essentiel pendant le développement. Cela vous permet d’inspecter rapidement vos données sans écrire de code de formatage personnalisé.

Défi

Facile

Rendons vos structures inspectables en dérivant le trait Debug ! Vous allez créer un système d'inventaire simple où les éléments peuvent être affichés à des fins de débogage.

Vous allez organiser votre code sur deux fichiers :

inventory.rs : Définissez une structure Item publique avec deux champs publics : name (String) et quantity (u32). Utilisez l'attribut #[derive(Debug)] pour implémenter automatiquement le trait Debug pour votre structure.
main.rs : Importez votre module d'inventaire et créez une instance de Item à l'aide des entrées fournies. Affichez l'élément à l'aide du formateur de débogage {:?} pour afficher sa structure interne.

L'intérêt de dériver Debug, c'est que Rust génère automatiquement le code de formatage pour vous : aucune implémentation manuelle n'est nécessaire ! Votre structure a simplement besoin de l'attribut, et elle devient affichable avec {:?}.

Votre sortie doit afficher l'élément au format de débogage de Rust :

Item { name: "{name}", quantity: {quantity} }

Par exemple, avec les entrées Keyboard et 15 :

Item { name: "Keyboard", quantity: 15 }

Vous recevrez deux entrées : le nom de l'élément et la quantité (à analyser comme u32).

REQUIRED OUTPUT FORMAT: [Your translated content here]

Essayez vous-même

mod inventory;

use inventory::Item;

fn main() {
    // Lire 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 quantity_str = String::new();
    std::io::stdin().read_line(&mut quantity_str).expect("Failed to read line");
    let quantity: u32 = quantity_str.trim().parse().expect("Failed to parse quantity");
    
    // TODO: Créer une instance d'Item avec le nom et la quantité donnés
    
    // TODO: Afficher l'item en utilisant le formateur de débogage {:?}
}