Das Debug-Trait

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

Die Standardbibliothek von Rust 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 du versuchst, 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 ist nicht implementiert

Der {:?}-Formatierer erfordert 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, die Debug-Implementierung automatisch zu generieren. Dies funktioniert, solange alle Felder in Ihrem Struct ebenfalls Debug implementieren (was die meisten Standardtypen tun).

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

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

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

Aufgabe

Einfach

Lass uns deine Structs inspizierbar machen, indem wir das Debug-Trait ableiten! Du wirst ein einfaches Inventarsystem erstellen, in dem Gegenstände zu Debugging-Zwecken ausgegeben werden können.

Du wirst deinen Code über zwei Dateien organisieren:

inventory.rs: Definiere ein öffentliches Item-Struct mit zwei öffentlichen Feldern: name (String) und quantity (u32). Verwende das Attribut #[derive(Debug)], um das Debug-Trait automatisch für dein Struct zu implementieren.
main.rs: Binde dein Inventar-Modul ein und erstelle eine Item-Instanz unter Verwendung der bereitgestellten Eingaben. Gib das Item 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 dich generiert – keine manuelle Implementierung erforderlich! Dein Struct benötigt nur das Attribut und wird mit {:?} ausgebbar.

Deine Ausgabe sollte das Item im Debug-Format von Rust anzeigen:

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

Zum Beispiel mit den Eingaben Keyboard und 15:

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

Du erhältst zwei Eingaben: den Namen des Items und die Menge (parse diese als u32).

Spickzettel

Das Debug-Trait ermöglicht es Ihnen, den Inhalt eines Structs zur Inspektion mit dem {:?}-Formatierer auszugeben.

Verwenden Sie das #[derive(Debug)]-Attribut, um Debug automatisch für Ihr Struct zu implementieren:

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

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

Für eine übersichtlichere Ausgabe (Pretty-Print) mit besserer Formatierung verwenden Sie {:#?}:

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

Das #[derive(Debug)]-Attribut funktioniert, solange alle Felder in Ihrem Struct ebenfalls Debug implementieren, was auf die meisten Standardtypen zutrifft.

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 Item mit dem Debug-Formatierer {:?} aus
}