Emprunt dans une boucle

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

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

Par exemple, considérons 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 provoquerait une erreur

Imagine les choses ainsi :

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

Maintenant, ce style :

for num in numbers.iter() {}

Est similaire à ceci :

for num in &numbers {}

Et une boucle de mutation, qui nécessite que le vecteur soit déclaré avec mut :

let mut numbers = vec![1, 2, 3, 4, 5];
for num in numbers.iter_mut() { 
    *num *= 2;
}

Peut également s’écrire ainsi :

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