web-dev-qa-db-fra.com

Est-il plus conventionnel de passer par valeur ou de passer par référence lorsque la méthode doit s'approprier la valeur?

Lorsque je passe un objet par référence à la méthode new() d'une structure et que la structure possédera l'objet, est-il plus conventionnel de:

  • passez l'objet par référence et faites to_owned() dans le new()
  • cloner l'objet avant d'appeler new(), et passer par valeur, en le déplaçant

Je peux penser aux avantages et aux inconvénients de chacun en termes de clarté et de séparation des préoccupations.

#[derive(Clone)]
struct MyState;

struct MyStruct {
    state: MyState,
}

impl MyStruct {
    pub fn new_by_ref(state: &MyState) -> Self {
        MyStruct {
            state: state.to_owned(),
        }
    }

    pub fn new_by_val(state: MyState) -> Self {
        MyStruct { state }
    }
}

fn main() {
    let state1 = MyState;
    let struct1 = MyStruct::new_by_ref(&state1);

    let state2 = MyState;
    let struct2 = MyStruct::new_by_val(state2.clone());
}
rustreferencepass-by-referencepass-by-value
13
Andrew Moffat

Passez par la valeur.

De cette manière, le programme peut éviter de doubler inutilement la valeur si l'appelant n'en a plus besoin.

Dans de nombreux cas, je recommande d'accepter tout ce qui peut être fait into le type possédé. Ceci est facilement démontré avec String:

struct MyStruct {
    state: String,
}

impl MyStruct {
    fn new(state: impl Into<String>) -> Self {
        let state = state.into();
        MyStruct { state }
    }
}

fn main() {
    let struct1 = MyStruct::new("foo");
    let struct2 = MyStruct::new(String::from("bar"));
}

Voir également:

13
Shepmaster