Vector von Objekten der Zugehörigkeit zu einer Eigenschaft

Betrachten Sie den folgenden code:

trait Animal {
    fn make_sound(&self) -> String;
}

struct Cat;
impl Animal for Cat {
    fn make_sound(&self) -> String {
        "meow".to_string()
    }
}

struct Dog;
impl Animal for Dog {
    fn make_sound(&self) -> String {
        "woof".to_string()
    }
}

fn main () {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    let v: Vec<Animal> = Vec::new();
    v.push(cat);
    v.push(dog);
    for animal in v.iter() {
        println!("{}", animal.make_sound());
    }
}

Der compiler sagt mir, dass v ist ein Vektor, der Animal wenn ich versuche zu pushen cat (type mismatch)

So, wie kann ich einen Vektor der Objekte der Zugehörigkeit zu einer Eigenschaft und ruft die entsprechenden trait-Methode auf jedes element?

InformationsquelleAutor Jacob Wang | 2014-09-12

polymorphism rust

62

Vec<Animal> ist nicht legal, aber der compiler kann nicht sagen, dass Sie da den Typ mismatch irgendwie blendet es. Wenn wir entfernen Sie die Anrufe an push, der compiler gibt die folgende Fehlermeldung:
```
<anon>:22:9: 22:40 error: instantiating a type parameter with an incompatible type `Animal`, which does not fulfill `Sized` [E0144]
<anon>:22     let mut v: Vec<Animal> = Vec::new();
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
Der Grund, warum das nicht legal ist, dass ein Vec<T> speichert viele T Objekte, die hintereinander im Speicher. Allerdings Animal ist eine Eigenschaft und Eigenschaften haben keine Größe (Cat und ein Dog sind garantiert nicht die selbe Größe haben).

Um dieses problem zu lösen, müssen wir etwas lagern, die eine Größe in der Vec. Die einfachste Lösung ist, um wickeln Sie die Werte in einer Box, d.h. Vec<Box<Animal>>. Box<T> der eine fixe Größe hat (einen "Fetten" Zeiger", wenn T ist eine Eigenschaft, einen einfachen Zeiger sonst).

Hier ist eine funktionierende main:
```
fn main () {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    let mut v: Vec<Box<Animal>> = Vec::new();
    v.push(Box::new(cat));
    v.push(Box::new(dog));
    for animal in v.iter() {
        println!("{}", animal.make_sound());
    }
}
```
- Dies scheint zu sein, mit trait-Objekte, d.h. dynamic dispatch. Allerdings, der Rost Programmiersprache Buch zu diesem Thema sagt "man kann immer haben eine dünne, statisch-wird ausgelöst, wrapper-Funktion, die eine dynamische dispatch, aber nicht Umgekehrt, d.h. statische Aufrufe sind flexibler." Gibt es eigentlich eine Möglichkeit, nicht Gebrauch-trait-Objekte und nur statische dispatch in diesem Fall? Ich begegnete auch den Anwendungsfall, in dem ich ein vector speichern von potenziell verschiedene Arten von Strukturen implementieren die gleiche Eigenschaft.
- Wenn Sie im Voraus wissen, welche konkreten Typen, die Sie stellen werden in der Vec können Sie eine enum statt (und dann den Zug vielleicht überflüssig). Ansonsten, Nein, Sie können nicht vermeiden, dynamic dispatch. Beachten Sie, dass dynamic dispatch ist nicht von Natur aus böse; es gibt Situationen, in denen es OK ist es zu benutzen!
- Der bevorzugte Weg, dies zu schreiben, ist jetzt Box<dyn Animal>.
InformationsquelleAutor Francis Gagné

Können Sie einen Referenz-Merkmal Objekt &Animal zu leihen, die Elemente und speichern diese Eigenschaft von Objekten in einem Vec. Sie können dann zählt es auf, und verwenden Sie die trait-Schnittstelle.

Änderung der Vec's generischer Typ, indem ein & vor der trait funktioniert:

fn main() {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    let mut v: Vec<&Animal> = Vec::new();
    //            ~~~~~~~
    v.push(&dog);
    v.push(&cat);
    for animal in v.iter() {
        println!("{}", animal.make_sound());
    }
    //Ownership is still bound to the original variable.
    println!("{}", cat.make_sound());
}

Dies ist ideal, wenn Sie wollen, kann die ursprüngliche variable zu halten Eigentums-und wiederzuverwenden.

Denken Sie daran, mit dem oben beschriebenen Szenario können Sie nicht das Eigentum an dog oder cat weil die Vec hat sich mit dieser konkreten Instanzen im gleichen Umfang.

Einführung in einen neuen Bereich kann helfen, behandeln, die insbesondere die situation:

fn main() {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    {
        let mut v: Vec<&Animal> = Vec::new();
        v.push(&dog);
        v.push(&cat);
        for animal in v.iter() {
            println!("{}", animal.make_sound());
        }
    }
    let pete_dog: Dog = dog;
    println!("{}", pete_dog.make_sound());
}

InformationsquelleAutor nate

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.