Le système de possession (ownership) est le concept fondamental de Rust pour garantir la sécurité de la mémoire au niveau de la compilation. Chaque variable a un propriétaire. Un seul propriétaire d'une ressource peut exister à un moment donné.
La possession est transférée (move) lors de l'assignation ou du passage à une fonction. Après le transfert, l'ancien propriétaire ne peut plus utiliser la valeur :
let s = String::from("hello"); let t = s; // s n'est plus accessible
Rust distingue également les emprunts (references).
&T — emprunt en lecture seule (borrow).&mut T — emprunt mutable (mutable borrow), mais il ne peut y en avoir qu'un seul à un moment donné.Grâce à ces règles, Rust garantit qu'il n'y aura pas de conditions de compétition sur les données utilisées après la libération de la mémoire et d'autres erreurs de gestion des ressources.
Peut-il y avoir plus d'un emprunt mutable (&mut T) en même temps sur une même valeur ? Pourquoi ?
Réponse : Non, à chaque instant, il peut y avoir soit un nombre illimité d'emprunts immuables, soit un seul emprunt mutable. Cela empêche les conditions de compétition. Exemple de code incorrect :
let mut s = String::from("hi"); let r1 = &mut s; let r2 = &mut s; // erreur de compilation !
Histoire
Dans un projet multithread, un développeur essayait de garder des références à un tampon mutable sans utiliser la possession, ce qui entraînait des pannes (use-after-free), lorsque le tampon était libéré avant la fin de l'utilisation de la référence. Rust n’a pas permis de compiler un tel code, donc il a fallu changer l'architecture.
Histoire
Au début d'un grand projet Rust, les programmeurs migraient du code depuis C++. Ils tentaient de combiner des habitudes obsolètes de travail avec des pointeurs "bruts", ce qui entraînait des erreurs de possession de ressources et des paniques constantes du vérificateur d'emprunt, jusqu'à ce que le problème architectural de possession soit résolu.
Histoire
Dans une bibliothèque d'analyse de chaînes, les erreurs de double libération de mémoire n'ont été évitées que grâce au strict système de possession de Rust. Une bibliothèque similaire en C++ a conduit à des bugs difficiles à attraper et des fuites de mémoire.