Les références à des traits dans les structures

C'est le point délicat de trait des objets, vous devez être très explicite au sujet de qui est propriétaire de l'objet sous-jacent.

En effet, lorsque vous utilisez un trait de caractère comme un type, l'objet sous-jacent doivent être stockés quelque part, comme trait d'objets sont en fait des références à un objet la mise en œuvre de la trait. C'est pourquoi vous ne pouvez pas avoir un nu - MyTrait comme un type, il doit être une référence &MyTrait ou une boîte Box<MyTrait>.

Avec des références

La première méthode que vous avez essayé a été a été avec une référence et le compilateur se sont plaints d'un manque de durée de vie de rédacteur de devis :

struct Bar {
   foo : &Foo,
}

Le problème est, une référence n'est pas propriétaire de l'objet sous-jacent, et d'un autre objet ou la portée doit être propriétaire de quelque part: vous êtes seulement à l'emprunter. Et donc, le compilateur a besoin d'informations sur combien de temps cette référence sera valide: si l'objet sous-jacent a été détruit, votre Barre d'instance aurait une référence à la mémoire libérée, ce qui est interdit !

L'idée ici est d'ajouter la durée de vie:

struct Bar<'a> {
   foo : &'a (Foo + 'a),
}

Ce que vous êtes en train de dire au compilateur est : "Ma Barre d'objet ne peut pas survivre à la Foo de référence à l'intérieur". Vous devez spécifier la durée de vie deux fois : une fois pour la durée de vie de la référence, et une fois pour le trait de l'objet lui-même, parce que les traits peuvent être mises en œuvre pour les références, et si l'objet sous-jacent est une référence, vous devez indiquer sa vie.

Sur le cas particulier serait écrit:

struct Bar<'a> {
   foo : &'a (Foo + 'static),
}

Dans ce cas, le 'static exige que l'objet sous-jacent doit être une véritable structure, ou un &'static de référence, mais d'autres références ne seront pas autorisés.

Aussi, pour construire votre objet, vous aurez à donner une référence à un autre objet, vous stockez vous-même.

Vous vous retrouvez avec quelque chose comme ceci :

trait Foo {}

struct MyFoo;

impl Foo for MyFoo {}

struct Bar<'a> {
    foo: &'a (Foo + 'a),
}

impl<'a> Bar<'a> {
    fn new(the_foo: &'a Foo) -> Bar<'a> {
        Bar { foo: the_foo }
    }

    fn get_foo(&'a self) -> &'a Foo {
        self.foo
    }
}

fn main() {
    let myfoo = MyFoo;
    let mybar = Bar::new(&myfoo as &Foo);
}

Avec Des Boîtes De

Une Boîte contrairement propriétaire de son contenu, ainsi il vous permet d'attribuer la propriété de l'objet sous-jacent à votre Barre de struct. Pourtant, comme cet objet sous-jacent pourrait être une référence, vous devez spécifier une durée de vie ainsi :

struct Bar<'a> {
    foo: Box<Foo + 'a>
}

Si vous savez que l'objet sous-jacent ne peut pas être une référence, vous pouvez également écrire:

struct Bar {
    foo: Box<Foo + 'static>
}

et la durée de vie problème disparaît complètement.

La construction de l'objet est donc semblable, mais plus simple car vous n'avez pas besoin de stocker l'objet sous-jacent de vous-même, elle est gérée par la boîte :

trait Foo {}

struct MyFoo;

impl Foo for MyFoo {}

struct Bar<'a> {
    foo: Box<Foo + 'a>,
}

impl<'a> Bar<'a> {
    fn new(the_foo: Box<Foo + 'a>) -> Bar<'a> {
        Bar { foo: the_foo }
    }

    fn get_foo(&'a self) -> &'a Foo {
        &*self.foo
    }
}

fn main() {
    let mybar = Bar::new(box MyFoo as Box<Foo>);
}

Dans ce cas, le 'static version :

trait Foo {}

struct MyFoo;

impl Foo for MyFoo {}

struct Bar {
    foo: Box<Foo + 'static>,
}

impl Bar {
    fn new(the_foo: Box<Foo + 'static>) -> Bar {
        Bar { foo: the_foo }
    }

    fn get_foo<'a>(&'a self) -> &'a Foo {
        &*self.foo
    }
}

fn main() {
    let mybar = Bar::new(box MyFoo as Box<Foo>);
    let x = mybar.get_foo();
}

Avec le strict valeur

Pour répondre à votre dernière question :

Ce qui est la conséquence de la suppression de l' & et seulement à l'aide de l'auto?

Si une méthode a une définition comme ceci :

fn unwrap(self) {}

Cela signifie qu'il va consommer votre objet dans le processus, et après l'appel de bar.unwrap(), vous ne serez pas en mesure d'utiliser bar plus.

C'est un processus utilisé de manière générale pour redonner de la propriété des données de votre structure de la propriété. Vous allez rencontrer beaucoup de unwrap() fonctions de la bibliothèque standard.