Rust
Konvertierungsmerkmale

Bemerkungen

Von

Das Merkmal " From Rust" ist ein allgemeines Merkmal zum Konvertieren zwischen Typen. Für zwei beliebige Typen TypeA und TypeB

impl From<TypeA> for TypeB

gibt an, dass eine Instanz von TypeB garantiert aus einer Instanz von TypeA . Eine Implementierung von From sieht so aus:

struct TypeA {
    a: u32,
}

struct TypeB {
    b: u32,
}

impl From<TypeA> for TypeB {
    fn from(src: TypeA) -> Self {
        TypeB {
            b: src.a,
        }
    }
}

AsRef & AsMut

std::convert::AsRef und std::convert::AsMut werden verwendet, um Typen billig in Referenzen std::convert::AsMut . Für die Typen A und B

impl AsRef<B> for A

zeigt an, dass A &A in A &B und

impl AsMut<B> for A

zeigt an, dass a &mut A in a &mut B .

Dies ist nützlich, wenn Sie Typkonvertierungen durchführen, ohne Werte zu kopieren oder zu verschieben. Ein Beispiel in der Standardbibliothek ist std::fs::File.open() :

fn open<P: AsRef<Path>>(path: P) -> Result<File>

Dadurch kann File.open() nicht nur Path , sondern auch OsStr , OsString , str , String und PathBuf mit impliziter Konvertierung OsString , da diese Typen alle AsRef<Path> implementieren.

Ausleihen, AusleihenMut und ToOwned

Die Merkmale std::borrow::BorrowMut std::borrow::Borrow und std::borrow::BorrowMut werden verwendet, um geborgte Typen wie eigene Typen zu behandeln. Für die Typen A und B

impl Borrow<B> for A

gibt an, dass ein geliehenes A verwendet werden kann, wenn ein B gewünscht wird. Zum Beispiel verwendet std::collections::HashMap.get() Borrow für seine get() -Methode, wodurch eine HashMap mit Schlüsseln von A mit einem &B indiziert werden kann.

Auf der anderen Seite implementiert std::borrow::ToOwned die umgekehrte Beziehung.

Mit den vorgenannten Typen A und B kann man also Folgendes implementieren:

impl ToOwned for B

Hinweis: Während A die Borrow<T> für mehrere verschiedene Typen T implementieren kann, kann B nur ToOwned einmalig implementieren.

Deref & DerefMut

Die Merkmale std::ops::Deref und std::ops::DerefMut werden zum Überladen des Dereferenzierungsoperators *x . Für die Typen A und B

impl Deref<Target=B> for A

zeigt an, dass eine Dereferenzierung einer Bindung von &A ein &B ergibt und

impl DerefMut for A

gibt an, dass die Deferenzierung einer Bindung von &mut A &mut B .

Deref (bzw. DerefMut ) bietet auch ein nützliches Sprachmerkmal namens Deref-Zwang , mit dem ein &A (bzw. &mut A ) automatisch zu einem &B (bzw. &mut B ) zwingen kann. Dies wird häufig bei der Konvertierung von String in &str , da &String implizit nach Bedarf in &str . &str .

Hinweis: DerefMut unterstützt die Angabe des resultierenden Typs nicht, es verwendet denselben Typ wie Deref .

Hinweis: Aufgrund der Verwendung eines verknüpften Typs (im Gegensatz zu AsRef ) kann ein bestimmter Typ nur jeweils Deref und DerefMut implementieren.