Rust:

Question

Rust Tutorials oft automatisch durch Verweis vorbei befürworten die Verwendung von

fn myFunc(x : &Something) -> .... 

ein Argument durch Verweis übergeben. Dies macht erforderlich, bei Aufrufort, um explizit drehen Sie den Referenzwerten erhalten:

myFunc(&myValue). 

Aber ich überprüft, und es ist möglich, die ‚ref‘ Schlüsselwort in der Regel in Muster zu tun, passend verwendet zu verwenden:

fn myFunc(ref x : Something) -> .... 

und dann kann ich es einfach nennen

myFunc(myValue) 

Speicher-weise, indem sie, funktioniert das, wie ich erwarte oder es myValue auf dem Stack kopiert, bevor myFunc aufrufe und dann einen Verweis erhalten zur Kopie?

Answer 1

Der Wert wird kopiert und auf die Kopie wird dann verwiesen.

fn f(ref mut x: int) { 
    *x = 12; 
} 

fn main() { 
    let mut x = 42; 
    f(x); 
    println!("{:d}", x); 
} 

Ausgang: 42

Answer 2

Wenn Sie eine Funktion wie f(x) rufen dann x immer von Wert übergeben wird.

fn f(ref x: int) { 
    // ... 
} 

entspricht

fn f(tmp: int) { 
    let ref x = tmp; 
    // or, 
    let x = &tmp; 

    // ... 
} 

d.h. die Referenzierung vollständig auf den Funktionsaufruf beschränkt ist.

Answer 3

Beide Funktionen erklären x zu &Something. Der Unterschied besteht darin, dass der erstere eine Referenz oder eine eigene Box als Parameter verwendet, während die zweite erwartet, dass es sich um einen regulären Stapelwert handelt. Zur Veranschaulichung:

struct Something; 

fn by_reference(x: &Something) { 
    println!("{:?}", x); // prints "&Something"" 
} 

fn on_the_stack(ref x: Something) { 
    println!("{:?}", x); // prints "&Something"" 
} 

fn main() { 
    let value_on_the_stack: Something = Something; 
    let owned: ~Something = ~Something; 
    let borrowed: &Something = &value_on_the_stack; 

    // Compiles: 
    on_the_stack(value_on_the_stack); 

    // Fail to compile: 
    // on_the_stack(owned); 
    // on_the_stack(borrowed); 

    // Dereferencing will do: 
    on_the_stack(*owned); 
    on_the_stack(*borrowed); 

    // Compiles: 
    by_reference(owned); 
    by_reference(borrowed); 

    // Fails to compile: 
    // by_reference(value_on_the_stack); 

    // Taking a reference will do: 
    by_reference(&value_on_the_stack); 
} 

Da on_the_stack einen Wert annimmt, es kopiert wird, dann entspricht die Kopie mit dem Muster im formalen Parameter (ref x in Ihrem Beispiel). Die Übereinstimmung bindet x an den Verweis auf den kopierten Wert.