Emprunt dans une boucle

En Rust, chaque valeur a un propriétaire, et lorsque vous utilisez une valeur dans une boucle, Rust doit savoir si vous voulez l’emprunter (simplement la consulter temporairement) ou en prendre possession (la consommer).

Cela est important, car si une boucle prend possession de vos données, vous ne pouvez plus utiliser ces données après la fin de la boucle. Comprendre cette distinction est essentiel pour écrire correctement des boucles en Rust.

Par exemple, considérez les données suivantes :

let numbers = vec![1, 2, 3, 4, 5];
let mut sum = 0;

Méthode 1 : Examiner les données (en utilisant &) :

for number in &numbers {
    sum += number;
}
println!("I can use it here: {:?}", numbers);

Méthode 2 : prendre les données (sans &) :

for number in numbers {
    sum += number;
}
// println!("Can't use {:?} anymore!", numbers);
// Cela causerait une erreur

Imaginez-le ainsi :

1. Utiliser &, c’est comme regarder un album photo : vous pouvez voir toutes les photos, mais l’album reste intact
2. Ne pas utiliser &, c’est comme retirer les photos : vous pouvez les utiliser, mais l’album sera vide ensuite

À présent, ce style :

for num in numbers.iter() {}

Est similaire à ceci :

for num in &numbers {}

Et une boucle de mutation :

for num in numbers.iter_mut() { 
    *num *= 2;
}

Can peut également s’écrire ainsi :

for num in &mut numbers { 
    *num *= 2;
}