Traits mit Parametern

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

Bisher haben unsere Trait-Methoden nur &self als Parameter akzeptiert. Aber Trait-Methoden können zusätzliche Parameter akzeptieren, genau wie reguläre Methoden – dies macht sie weitaus nützlicher für reale Anwendungen.

Beim Definieren eines Traits können Sie alle benötigten Parameter 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 jeweils zwei Ganzzahlen zusätzlich zu &self akzeptieren. Jeder Typ, der dieses Trait implementiert, muss beide Operationen mit genau diesen Signaturen bereitstellen.

Hier ist, wie ein Struct dies implementieren könnte:

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 können Sie 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. Dies ermöglicht es verschiedenen Typen, dieselben Operationen auf ihre eigene Weise auszuführen – vielleicht könnte ein LoggingCalc jede Operation ausgeben, bevor das Ergebnis zurückgegeben wird.

Aufgabe

Einfach

Lassen Sie uns ein Toolkit zur String-Manipulation erstellen, bei dem verschiedene Prozessoren Text auf ihre eigene Weise transformieren können! Sie werden ein TextProcessor-Trait mit Methoden erstellen, die Parameter akzeptieren, und dieses dann für zwei verschiedene Prozessortypen implementieren.

Sie werden Ihren Code über drei Dateien organisieren:

processor.rs: Definieren Sie 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: Erstellen Sie zwei öffentliche Structs, die Ihr Trait implementieren:
- SimpleProcessor — ein Unit-Struct, das Text mit Leerzeichen zwischen jeder Wiederholung wiederholt (z. B. wird "Hi" 3-mal wiederholt zu "Hi Hi Hi") und kürzt, indem es einfach bei der maximalen Länge abschneidet
- FancyProcessor — ein Unit-Struct, das Text mit " * " zwischen den Wiederholungen wiederholt (z. B. wird "Hi" 3-mal wiederholt zu "Hi * Hi * Hi") und kürzt, indem es "..." hinzufügt, wenn der Text gekürzt wurde (nur wenn der Originaltext länger als max_len war)
main.rs: Führen Sie Ihre Module zusammen und demonstrieren Sie, wie dieselben Trait-Methoden unterschiedliche Ergebnisse liefern, je nachdem, welchen Prozessor Sie verwenden.

Erstellen Sie in Ihrer Hauptdatei beide Prozessoren und verwenden Sie die Eingaben, um sie zu testen. Sie erhalten drei Eingaben: einen Text-String, eine Anzahl an Wiederholungen und eine maximale Länge.

Geben Sie 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...

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

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

Spickzettel

Trait-Methoden können zusätzliche Parameter über &self hinaus akzeptieren:

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

Implementierung eines Traits mit Parametern:

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
    }
}

Verwendung von Trait-Methoden mit Argumenten:

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

Der Trait definiert, welche Parameter jede Methode akzeptiert, während die Implementierung definiert, wie diese Parameter verwendet werden.

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: Die Prozessoren verwenden, um den Text zu transformieren und die Ergebnisse auszugeben
    // Vier Zeilen ausgeben:
    // Simple repeat: {result}
    // Simple truncate: {result}
    // Fancy repeat: {result}
    // Fancy truncate: {result}
}