Was bedeutet das kaufmännische Und in einem Rust-Typ?

Question

Ich habe diesen Code in der Dokumentation Rust gesehen:

fn eat(&self) { 
    println!("{} is done eating.", self.name); 
} 

etwas macht die & in &self bedeuten?

Answer 1

Dies bedeutet, dass Sie eine Referenz an das Objekt übergeben, anstatt das Objekt selbst zu verschieben. Es ist Import dies zu unterscheiden, weil, wenn Ihre Funktion ausgesehen:

fn eat(self) { 
    println!("{} is done eating.", self.name); 
} 

und Sie versuchte es dann über die Variable nach dem Aufruf, erhalten Sie einen Fehler würden

object = Foo::new(); 
object.eat(); 
object.something(); // error, because you moved object in eat 

, weil, wenn Sie don‘ t Geben Sie & an, rost verschiebt den Wert in die Funktion und Ihre ursprüngliche Bindung hat keine Eigentumsrechte mehr. Dieses minimal Beispiel Besuche ich erstellt (playground version):

struct Foo { 
    x : u32 
} 

impl Foo { 

    fn eat(self) { 
     println!("eating"); 
    } 

    fn something(&self) { 
     println!("else"); 
    } 

} 

fn main() { 
    println!("Hello, world!"); 

    let g = Foo { x: 5 }; 
    g.eat(); 
    g.something(); // if this comes before eat, no errors because we arent moving 
} 

Jetzt something wechseln voreat aufgerufen werden. Da something nur eine Referenz, g dauert, hat noch Besitz und Sie können weitermachen. eat bewegt sich dagegen g und Sie können g nicht mehr verwenden.

Answer 2

Die Antwort ist in der book: Eigentum/Kreditaufnahme ist eine der wichtigsten Eigenschaften von Rost.

Versuchen Sie, das Buch zu lesen, es lohnt sich wirklich die Zeit, die Sie darauf verbringen werden.