Generische Methoden

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

Eine generische Struktur kann jeden Typ enthalten, ist aber ohne Methoden zur Interaktion mit ihren Daten nicht sehr nützlich. Um Methoden für eine generische Struktur zu definieren, benötigst du eine spezielle Syntax im impl-Block.

Der Schlüssel besteht darin, den generischen Parameter direkt auf impl zu deklarieren:

struct Wrapper<T> {
    value: T,
}

impl<T> Wrapper<T> {
    fn get(&self) -> &T {
        &self.value
    }
}

Beachte das impl<T> vor Wrapper<T>. Dadurch wird Rust mitgeteilt, dass T ein generischer Typparameter für den gesamten Implementierungsblock ist. Ohne diese Deklaration würde Rust nach einem konkreten Typ namens T suchen und ihn nicht finden.

Die Methode get gibt &T zurück: eine Referenz auf den Typ, den der Wrapper enthält. Das funktioniert unabhängig davon, ob T eine Ganzzahl, eine Zeichenkette oder ein anderer Typ ist:

let num_wrapper = Wrapper { value: 100 };
let text_wrapper = Wrapper { value: "Rust" };

println!("{}", num_wrapper.get());  // 100
println!("{}", text_wrapper.get()); // Rust

Dieselbe Methodendefinition funktioniert für beide, weil sich der generische Typ T zur Kompilierzeit an jeden konkreten Typ anpasst.

Aufgabe

Einfach

Erweitern wir deinen generischen Container um Methoden! Du erstellst eine Box-Struktur (nicht zu verwechseln mit Rusts standardmäßiger Box), die jeden Typ aufnehmen kann und Methoden zur Interaktion mit ihrem Inhalt bereitstellt.

Du organisierst deinen Code auf zwei Dateien verteilt:

mybox.rs: Definiere eine öffentliche generische Struktur namens MyBox<T> mit einem privaten Feld contents vom Typ T. Implementiere Methoden für diese Struktur:
- Eine zugehörige Funktion new, die eine neue MyBox mit dem angegebenen Wert erstellt
- Eine peek-Methode, die eine Referenz auf den Inhalt zurückgibt (unter Verwendung von &self)
- Eine replace-Methode, die einen neuen Wert entgegennimmt und den aktuellen Inhalt ersetzt (unter Verwendung von &mut self)
main.rs: Binde dein Modul ein und demonstriere, dass die generischen Methoden mit unterschiedlichen Typen funktionieren. Du erstellst Boxen, siehst dir deren Inhalte an und ersetzt Werte, um die Methoden in Aktion zu zeigen.

Denke an die wichtige Syntax zum Implementieren von Methoden für eine generische Struktur: Du benötigst impl<T> vor MyBox<T>, um Rust mitzuteilen, dass T für den gesamten Implementierungsblock ein generischer Parameter ist.

Demonstriere in deiner Hauptdatei deine MyBox, indem du:

Eine Box mit einer Ganzzahl erstellst (erste Eingabe, als i32 geparst)
Den Inhalt abfragst und den Wert ausgibst
Den Inhalt durch eine neue Ganzzahl ersetzt (zweite Eingabe, als i32 geparst)
Erneut den Inhalt abfragst, um den aktualisierten Wert anzuzeigen
Eine zweite Box mit einer Zeichenkette erstellst (dritte Eingabe)
Den Inhalt der Zeichenketten-Box abfragst

Deine Ausgabe sollte diesem Format folgen:

Integer box contains: {value}
After replace: {value}
String box contains: {value}

Zum Beispiel mit den Eingaben 10, 25 und Rust:

Integer box contains: 10
After replace: 25
String box contains: Rust

Du erhältst drei Eingaben: eine anfängliche Ganzzahl, eine Ersatz-Ganzzahl und einen Zeichenkettenwert.

Probier es selbst

mod mybox;

use mybox::MyBox;

fn main() {
    // Eingaben lesen
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let initial_int: i32 = input1.trim().parse().expect("Invalid integer");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let replacement_int: i32 = input2.trim().parse().expect("Invalid integer");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let string_value = input3.trim().to_string();

    // TODO: Erstelle eine MyBox mit der initialen Ganzzahl
    
    // TODO: Peek at its contents and print: "Integer box contains: {value}"
    
    // TODO: Ersetze den Inhalt mit der Ersatz-Ganzzahl
    
    // TODO: Peek again and print: "After replace: {value}"
    
    // TODO: Erstelle eine zweite MyBox mit dem String-Wert
    
    // TODO: Peek at the string box and print: "String box contains: {value}"
}