Передача компонента указателя по значению

Question

Я только что начал с Rust, поэтому некоторые из моих понятий могут быть неправильными. Я бы очень признателен за исправления, если это так.

Я следил за lifetimes guide и пробовал некоторые из примеров. Я немного изменил пример прямоугольника.

Я изменил функцию compute_distance, чтобы принять Point по значению в первом параметре. Затем я удалил & до on_the_stack.origin по телефону compute_distance.

Это дает мне следующее сообщение об ошибке:

cannot move out of dereference of & -pointer

Если вместо этого я добавить & до on_the_stack.origin вызова, а также принять Point по ссылке в функции compute_distance, она работает без сучка и задоринки.

Второй способ работы имеет смысл для меня, но почему мой оригинальный подход выдает ошибку?

use std::num::Float; 

struct Point { 
    x : f64, 
    y : f64 
} 

struct Size {w: f64, h: f64} 
struct Rectangle {origin: Point, size: Size} 

#[cfg(not(test))] 
fn main() { 
    let on_the_stack = &Rectangle{origin: Point {x: 1.0, y: 2.0}, 
            size: Size {w: 3.0, h: 4.0}}; 

    let on_the_heap = box Rectangle {origin: Point {x: 5.0, y: 6.0}, 
            size: Size {w: 3.0, h: 4.0}}; 

    println!("Distance: {}", compute_distance(on_the_stack.origin,&on_the_heap.origin)); 
} 

fn compute_distance (p1:Point,p2:&Point) -> f64 { 
    let x_d = p1.x - p2.x; 
    let y_d = p1.y - p2.y; 
    Float::sqrt(x_d * x_d + y_d * y_d) 
} 

Answer 1

Как вы сказали, Измененная compute_distance хочет значение в качестве первого параметра. Это означает, что функция переходит в собственность аргумента.

Однако вы пытаетесь передать меньший кусок структуры (origin встроен в Rectangle). Для этого Rust должен был бы отдать часть от Rectangle к методу, но точно, в каком состоянии осталось бы Rectangle? Очень сломанный, поэтому Rust препятствует тому, чтобы вы это делали. Да, ты не стрелял в ногу!

«Но подождите», вы говорите: «Это абсолютно здорово, если функция получает копию из origin». Вы, как человек, можете признать, что и сказать компилятор, что это «абсолютно здорово»:

#[deriving(Copy)] 
struct Point { /* ... */ } 

Теперь Rust знает, что это безопасно, чтобы сделать бит для битой копии Point, если он хотел бы к. Ура!

«Но ждать», вы говорите, «что, если это не круто сделать бит-в-бит копии? Моя структура нуждается в большем количестве, чем любовь проходит лечение, как мешок бит!». Опять же, как умный человек, вы можете выразить, что:

#[deriving(Clone)] 
struct Point { /* ... */ } 

// later... 

on_the_stack.origin.clone() 

Теперь вы можете сделать явный вызов (clone()), чтобы получить семантический дубликат опциона. Поскольку это может быть дорогостоящей операцией, компилятор не сделает это за вас.

записку о deriving

Как я пишу этот ответ, deriving переходит к derive. При необходимости отрегулируйте свой код.