Das Debug-Trait

Teil des Abschnitts Object Oriented Programming der Rust-Journey von Coddy — Lektion 35 von 61.

Rusts Standardbibliothek enthält viele vordefinierte Traits, die gängige Funktionalitäten bereitstellen. Einer der nützlichsten für die Entwicklung ist der Debug-Trait, der es ermöglicht, den Inhalt eines Structs zur Inspektion auszugeben.

Wenn Sie versuchen, eine benutzerdefinierte Struktur direkt auszugeben, weiß Rust nicht, wie sie angezeigt werden soll:

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

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

Der {:?}-Formatierer benötigt das Debug-Trait. Anstatt es manuell zu implementieren, bietet Rust eine Abkürzung – das #[derive]-Attribut. Platzieren Sie es direkt über Ihrer Struct-Definition:

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

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

Das #[derive(Debug)]-Attribut weist den Compiler an, automatisch die Debug-Implementierung zu generieren. Dies funktioniert, solange alle Felder in deinem Struct ebenfalls Debug implementieren (was auf die meisten Standardtypen zutrifft).

Für eine besser lesbare Ausgabe bei verschachtelten Strukturen verwende {:#?} für Pretty-Printing:

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

Das Ableiten von Debug ist während der Entwicklung essenziell – es ermöglicht Ihnen, Ihre Daten schnell zu inspizieren, ohne benutzerdefinierten Formatierungscode schreiben zu müssen.

Aufgabe

Einfach

Lassen Sie uns Ihre Structs inspizierbar machen, indem wir das Debug-Trait ableiten! Sie werden ein einfaches Inventarsystem erstellen, in dem Elemente zu Debugging-Zwecken ausgegeben werden können.

Sie werden Ihren Code über zwei Dateien organisieren:

inventory.rs: Definieren Sie ein öffentliches Item-Struct mit zwei öffentlichen Feldern: name (String) und quantity (u32). Verwenden Sie das Attribut #[derive(Debug)], um das Debug-Trait automatisch für Ihr Struct zu implementieren.
main.rs: Binden Sie Ihr Inventarmodul ein und erstellen Sie eine Item-Instanz unter Verwendung der bereitgestellten Eingaben. Geben Sie das Element mit dem Debug-Formatierer {:?} aus, um seine interne Struktur anzuzeigen.

Das Schöne am Ableiten von Debug ist, dass Rust den Formatierungscode automatisch für Sie generiert – keine manuelle Implementierung erforderlich! Ihr Struct benötigt lediglich das Attribut und wird mit {:?} ausgebbar.

Ihre Ausgabe sollte das Element im Debug-Format von Rust anzeigen:

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

Zum Beispiel mit den Eingaben Keyboard und 15:

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

Sie erhalten zwei Eingaben: den Namen des Elements und die Menge (parsen als u32).

Probier es selbst

mod inventory;

use inventory::Item;

fn main() {
    // Eingabe lesen
    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: Erstelle eine Item-Instanz mit dem angegebenen Namen und der Menge
    
    // TODO: Gib das Element mit dem Debug-Formatierer {:?} aus
}