Das Debug-Trait

Teil des Abschnitts Objektorientierte Programmierung der Rust-Journey von Coddy. Lektion 35 von 61.

Die Standardbibliothek von Rust enthält viele vordefinierte Traits, die allgemeine Funktionalität bereitstellen. Einer der nützlichsten für die Entwicklung ist der Trait Debug, mit dem du den Inhalt einer Struktur zur Überprüfung ausgeben kannst.

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 nicht implementiert

Der Formatierer {:?} erfordert das Debug-Trait. Anstatt es manuell zu implementieren, bietet Rust eine Abkürzung: das #[derive]-Attribut. Platziere es direkt über deiner 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 deiner Struktur ebenfalls Debug implementieren (was bei den meisten Standardtypen der Fall ist).

Für eine besser lesbare Ausgabe mit verschachtelten Strukturen verwende {:#?} für die formatierte Ausgabe:

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

Das Ableiten von Debug ist während der Entwicklung unerlässlich. Damit kannst du deine Daten schnell überprüfen, ohne benutzerdefinierten Formatierungscode schreiben zu müssen.

Aufgabe

Einfach

Machen wir deine Structs durch Ableiten des Debug-Traits inspizierbar! Du erstellst ein einfaches Inventarsystem, in dem Items zu Debugging-Zwecken ausgegeben werden können.

Du organisierst deinen Code über zwei Dateien:

inventory.rs: Definiere eine öffentliche Item-Struct mit zwei öffentlichen Feldern: name (String) und quantity (u32). Verwende das Attribut #[derive(Debug)], um das Debug-Trait automatisch für deine Struct zu implementieren.
main.rs: Binde dein inventory-Modul ein und erstelle eine Item-Instanz anhand der bereitgestellten Eingaben. Gib das Item mit dem Debug-Formatter {:?} 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! Deine Struct benötigt lediglich das Attribut und kann anschließend mit {:?} ausgegeben werden.

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 (als u32 parsen).

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 gegebenen Namen und der Menge
    
    // TODO: Gib das Item mit dem Debug-Formatter {:?} aus
}