Traits mit Parametern

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

Bisher haben unsere Trait-Methoden nur &self als Parameter entgegengenommen. Trait-Methoden können jedoch ebenso wie reguläre Methoden zusätzliche Parameter akzeptieren. Dadurch sind sie für Vorgänge in der realen Welt weitaus nützlicher.

Beim Definieren eines Traits kannst du alle Parameter, die du benötigst, in die Methodensignaturen aufnehmen:

trait Calculator {
    fn add(&self, a: i32, b: i32) -> i32;
    fn multiply(&self, a: i32, b: i32) -> i32;
}

Dieses Calculator-Trait erfordert zwei Methoden, die zusätzlich zu &self jeweils zwei Ganzzahlen akzeptieren. Jeder Typ, der dieses Trait implementiert, muss beide Operationen mit genau diesen Signaturen bereitstellen.

So könnte eine Struktur dies implementieren:

struct BasicCalc;

impl Calculator for BasicCalc {
    fn add(&self, a: i32, b: i32) -> i32 {
        a + b
    }
    
    fn multiply(&self, a: i32, b: i32) -> i32 {
        a * b
    }
}

Jetzt kannst du diese Methoden mit Argumenten verwenden:

let calc = BasicCalc;
println!("{}", calc.add(5, 3));       // 8
println!("{}", calc.multiply(4, 7));  // 28

Das Trait definiert, welche Parameter jede Methode akzeptiert, während die Implementierung definiert, wie diese Parameter verwendet werden. Dadurch können verschiedene Typen dieselben Operationen auf ihre eigene Weise ausführen: Vielleicht könnte ein LoggingCalc jede Operation ausgeben, bevor es das Ergebnis zurückgibt.

Aufgabe

Einfach

Lass uns ein Toolkit zur Zeichenkettenbearbeitung erstellen, in dem verschiedene Prozessoren Text auf ihre eigene Weise umwandeln! Du erstellst ein TextProcessor-Trait mit Methoden, die Parameter akzeptieren, und implementierst es anschließend für zwei verschiedene Prozessortypen.

Du organisierst deinen Code über drei Dateien:

processor.rs: Definiere ein öffentliches TextProcessor-Trait mit zwei Methoden, die Parameter akzeptieren:
- repeat(&self, text: &str, times: u32) -> String: wiederholt den angegebenen Text eine bestimmte Anzahl von Malen
- truncate(&self, text: &str, max_len: usize) -> String: kürzt den Text auf die angegebene maximale Länge
processors.rs: Erstelle zwei öffentliche Strukturen, die dein Trait implementieren:
- SimpleProcessor: eine Unit-Struktur, die zwischen jede Wiederholung Leerzeichen setzt (z. B. wird eine dreimalige Wiederholung von "Hi" zu "Hi Hi Hi") und den Text einfach an der maximalen Länge abschneidet
- FancyProcessor: eine Unit-Struktur, die zwischen die Wiederholungen " * " setzt (z. B. wird eine dreimalige Wiederholung von "Hi" zu "Hi * Hi * Hi") und beim Kürzen "..." hinzufügt, wenn der Text gekürzt wurde (nur wenn der ursprüngliche Text länger als max_len war)
main.rs: Führe deine Module zusammen und zeige, wie dieselben Trait-Methoden abhängig vom verwendeten Prozessor unterschiedliche Ergebnisse liefern.

Erstelle in deiner Hauptdatei beide Prozessoren und verwende die Eingaben, um sie zu testen. Du erhältst drei Eingaben: eine Textzeichenkette, eine Anzahl von Wiederholungen und eine maximale Länge.

Gib vier Zeilen aus, die das Verhalten jedes Prozessors zeigen:

Simple repeat: {result}
Simple truncate: {result}
Fancy repeat: {result}
Fancy truncate: {result}

Zum Beispiel mit den Eingaben Hello, 3 und 4:

Simple repeat: Hello Hello Hello
Simple truncate: Hell
Fancy repeat: Hello * Hello * Hello
Fancy truncate: Hell...

Beachte, wie beide Prozessoren denselben TextProcessor-Vertrag erfüllen, aber jeder den Text auf seine eigene Weise umwandelt. Das Trait definiert, welche Parameter die Methoden akzeptieren, während jede Implementierung entscheidet, wie sie diese verwendet!

Du erhältst drei Eingaben: den zu verarbeitenden Text, die Anzahl der Wiederholungen (als u32 parsen) und die maximale Länge für die Kürzung (als usize parsen).

Probier es selbst

mod processor;
mod processors;

use processor::TextProcessor;
use processors::{SimpleProcessor, FancyProcessor};

fn main() {
    // Eingaben lesen
    let mut text = String::new();
    std::io::stdin().read_line(&mut text).expect("Failed to read line");
    let text = text.trim();
    
    let mut times_input = String::new();
    std::io::stdin().read_line(&mut times_input).expect("Failed to read line");
    let times: u32 = times_input.trim().parse().expect("Failed to parse times");
    
    let mut max_len_input = String::new();
    std::io::stdin().read_line(&mut max_len_input).expect("Failed to read line");
    let max_len: usize = max_len_input.trim().parse().expect("Failed to parse max_len");
    
    // Prozessoren erstellen
    let simple = SimpleProcessor;
    let fancy = FancyProcessor;
    
    // TODO: Verwende die Prozessoren, um den Text zu transformieren und die Ergebnisse auszugeben
    // Gib vier Zeilen aus:
    // Simple repeat: {result}
    // Simple truncate: {result}
    // Fancy repeat: {result}
    // Fancy truncate: {result}
}