Operatorüberladung in Rust

Einführung

In diesem Lab untersuchen wir die Überladung von Operatoren in Rust und wie dies durch Traits erreicht werden kann. Operatoren in Rust können mithilfe von Traits überladen werden, was es ihnen ermöglicht, unterschiedliche Aufgaben basierend auf ihren Eingabeargumenten auszuführen. Der +-Operator ist beispielsweise syntaktischer Zucker für die add-Methode und kann von jedem Implementierer des Add-Traits verwendet werden. Die Traits, die Operatoren überladen, einschließlich Add, können in core::ops gefunden werden. Der bereitgestellte Rust-Code zeigt, wie der +-Operator für benutzerdefinierte Typen Foo und Bar überladen wird, was jeweils zu unterschiedlichen Ausgabetypen FooBar und BarFoo führt.

Hinweis: Wenn das Lab keinen Dateinamen angibt, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden, es mit rustc main.rs &&./main kompilieren und ausführen.

Operatorüberladung

In Rust können viele Operatoren über die Verwendung von Traits überladen werden. Das heißt, einige Operatoren können verwendet werden, um unterschiedliche Aufgaben basierend auf ihren Eingabeargumenten zu erledigen. Dies ist möglich, da Operatoren syntaktischer Zucker für Methodenaufrufe sind. Beispielsweise ruft der +-Operator in a + b die add-Methode auf (wie in a.add(b)). Diese add-Methode ist Teil des Add-Traits. Folglich kann der +-Operator von jedem Implementierer des Add-Traits verwendet werden.

Eine Liste der Traits, wie Add, die Operatoren überladen, kann in core::ops gefunden werden.

use std::ops;

struct Foo;
struct Bar;

#[derive(Debug)]
struct FooBar;

#[derive(Debug)]
struct BarFoo;

// Das `std::ops::Add`-Trait wird verwendet, um die Funktionalität von `+` anzugeben.
// Hier definieren wir `Add<Bar>` - das Trait für die Addition mit einem rechten Operanden vom Typ `Bar`.
// Der folgende Block implementiert die Operation: Foo + Bar = FooBar
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        println!("> Foo.add(Bar) wurde aufgerufen");

        FooBar
    }
}

// Indem wir die Typen umkehren, implementieren wir eine nicht-kommutative Addition.
// Hier definieren wir `Add<Foo>` - das Trait für die Addition mit einem rechten Operanden vom Typ `Foo`.
// Dieser Block implementiert die Operation: Bar + Foo = BarFoo
impl ops::Add<Foo> for Bar {
    type Output = BarFoo;

    fn add(self, _rhs: Foo) -> BarFoo {
        println!("> Bar.add(Foo) wurde aufgerufen");

        BarFoo
    }
}

fn main() {
    println!("Foo + Bar = {:?}", Foo + Bar);
    println!("Bar + Foo = {:?}", Bar + Foo);
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab zu Operatorüberladung abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.