Mehrfache Bounds

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

Manchmal reicht eine einzelne Trait-Beschränkung nicht aus. Du benötigst möglicherweise einen generischen Typ, der sowohl ausgegeben werden als auch eine Zusammenfassung bereitstellen kann. Rust ermöglicht es dir, mehrere Traits mithilfe der Syntax + zu verlangen.

So gibst du an, dass ein Typ zwei Traits implementieren muss:

use std::fmt::Display;

trait Summary {
    fn summarize(&self) -> String;
}

fn announce<T: Display + Summary>(item: T) {
    println!("Breaking news: {}", item);
    println!("Summary: {}", item.summarize());
}

Die Bound T: Display + Summary bedeutet: „T muss sowohl Display als auch Summary implementieren.“ Innerhalb der Funktion kannst du die Fähigkeiten beider Traits verwenden: mit {} ausgeben (von Display) und summarize() aufrufen (von Summary).

Du kannst so viele Traits verketten, wie du benötigst:

fn process<T: Display + Summary + Clone>(item: T) {
    // Kann ausgeben, zusammenfassen UND klonen
}

Dieses Muster ist unerlässlich, wenn deine Funktion auf mehreren Verhaltensweisen beruht. Statt jeden beliebigen Typ zu akzeptieren und zu hoffen, dass es funktioniert, deklarierst du ausdrücklich, welche Fähigkeiten genau erforderlich sind, und der Compiler setzt dies zur Kompilierungszeit durch.

Aufgabe

Einfach

Lass uns ein Produktinspektionssystem entwickeln, bei dem Elemente mehrere Fähigkeiten benötigen! Du erstellst eine generische Funktion, die nur Typen akzeptiert, die sowohl ein benutzerdefiniertes Trait als auch ein Standard-Trait implementieren, und demonstrierst damit, wie die Syntax + mehrere Bounds kombiniert.

Du organisierst deinen Code über zwei Dateien:

product.rs: Definiere ein öffentliches Inspectable-Trait mit einer Methode namens inspect, die &self übernimmt und einen String mit Inspektionsdetails zurückgibt. Erstelle anschließend eine öffentliche Gadget-Struktur mit den öffentlichen Feldern name (String) und serial (u32). Dein Gadget soll sowohl Inspectable (mit der Rückgabe Inspecting: {name}) als auch std::fmt::Display (formatiert als {name} (SN: {serial})) implementieren. Erstelle schließlich eine öffentliche generische Funktion namens full_report, die jeden Typ T akzeptiert, der sowohl Display als auch Inspectable implementiert. Diese Funktion soll zwei Zeilen ausgeben: zuerst das Element mit dem Formatierer {}, danach das Ergebnis des Aufrufs von inspect().
main.rs: Binde dein Produktmodul ein und erstelle mithilfe der bereitgestellten Eingaben eine Gadget-Instanz. Rufe full_report mit deinem Gadget auf, um zu zeigen, dass es beide Trait-Anforderungen erfüllt.

Die Stärke mehrerer Bounds besteht darin, dass deine Funktion full_report Fähigkeiten aus beiden Traits verwenden kann: Sie stellt das Element ansprechend dar UND ruft Inspektionsdetails ab – alles garantiert zur Compile-Zeit.

Deine Ausgabe sollte sowohl das Anzeigeformat als auch das Inspektionsergebnis zeigen:

{name} (SN: {serial})
Inspecting: {name}

Beispielsweise bei den Eingaben Smartwatch und 98765:

Smartwatch (SN: 98765)
Inspecting: Smartwatch

Du erhältst zwei Eingaben: den Namen des Gadgets und die Seriennummer (als u32 parsen).

Probier es selbst

mod product;

use product::{Gadget, full_report};

fn main() {
    // Eingaben 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 serial_input = String::new();
    std::io::stdin().read_line(&mut serial_input).expect("Failed to read line");
    let serial: u32 = serial_input.trim().parse().expect("Failed to parse serial");
    
    // TODO: Erstelle eine Gadget-Instanz mit dem name und der serial
    
    // TODO: Rufe full_report mit deinem gadget auf
}