Borrow & ownership

fn main() {
    let s = String::from("hello");   // s possède la String
    println!("{s}");
}                                     // s sort de portée : la mémoire est libérée

fn main() {
    let a = String::from("a");
    {
        let b = String::from("b");
        println!("{a} {b}");
    }                              // b est libérée ici
    // println!("{b}");            // ERREUR : b n'existe plus
}                                  // a est libérée ici

struct Bruyant(&'static str);

impl Drop for Bruyant {
    fn drop(&mut self) {
        println!("libération de {}", self.0);
    }
}

fn main() {
    let _a = Bruyant("a");
    let _b = Bruyant("b");
    println!("fin de main");
}
// fin de main
// libération de b
// libération de a

Les variables sont libérées dans l'ordre inverse de leur déclaration : une valeur déclarée après peut emprunter une valeur déclarée avant, celle-ci est donc toujours libérée en dernier. Les champs d'une struct sont libérés dans l'ordre de déclaration.

let gros = vec![0u8; 100_000_000];
traiter(&gros);
drop(gros);               // libère maintenant au lieu d'attendre la fin du bloc
// suite longue qui n'a plus besoin de gros

fn traiter(_: &[u8]) {}

drop(x) n'a rien de magique : c'est une fonction qui prend la valeur et ne fait rien, donc la valeur est libérée à sa sortie. Elle sert aussi à relâcher un verrou avant la fin d'un bloc.

let s1 = String::from("hello");
let s2 = s1;                       // la String est DÉPLACÉE de s1 vers s2
// println!("{s1}");               // ERREUR E0382 : borrow of moved value
println!("{s2}");

Seul l'en-tête (pointeur, longueur, capacité) est recopié ; les octets sur le tas ne bougent pas. Si s1 restait valide, deux variables posséderaient le même bloc et le libéreraient deux fois. Rust invalide donc s1.

fn prendre(s: String) {
    println!("{s}");
}                                   // s est libérée ici

fn main() {
    let texte = String::from("hello");
    prendre(texte);                 // déplacée dans la fonction
    // println!("{texte}");         // ERREUR
}

fn creer() -> String {
    let s = String::from("nouveau");
    s                               // déplacée vers l'appelant : pas libérée ici
}

fn ajouter_point(mut s: String) -> String {
    s.push('.');
    s                               // prise puis rendue
}

fn main() {
    let a = creer();
    let a = ajouter_point(a);
}

Prendre puis rendre fonctionne, mais c'est lourd : une référence fait la même chose plus simplement (section 6).

let nom = String::from("Ada");
let v = vec![nom];                  // déplacée dans le Vec
// println!("{nom}");               // ERREUR

let titre = String::from("x");
let afficher = move || println!("{titre}");   // move : la closure possède titre
afficher();
// println!("{titre}");             // ERREUR

let s = String::from("a");
for _ in 0..3 {
    // prendre(s);                  // ERREUR : déplacée au premier tour, absente au deuxième
    prendre(s.clone());             // une copie à chaque tour
}

fn prendre(_: String) {}

struct Personne { nom: String, age: u32 }

let p = Personne { nom: String::from("Ada"), age: 36 };
let nom = p.nom;                    // seul le champ nom est déplacé
println!("{}", p.age);              // OK : age est encore là
// println!("{}", p.nom);           // ERREUR : déplacé
// let q = p;                       // ERREUR : p est incomplète

let s = String::from("a");
let condition = true;
if condition {
    drop(s);
}
// println!("{s}");                 // ERREUR : peut-être déplacée

Le compilateur raisonne sur tous les chemins possibles : si un seul chemin déplace la valeur, elle est considérée comme indisponible après.

let x = 5;
let y = x;            // copie : x reste utilisable
println!("{x} {y}");

Un type Copy est copié bit à bit au lieu d'être déplacé. Sont Copy :

• entiers, flottants, bool, char ;
• références partagées &T ;
• tuples et tableaux dont tous les éléments sont Copy ;
• tes types avec #[derive(Clone, Copy)], si tous leurs champs sont Copy.

Ne sont pas Copy : String, Vec, Box, HashMap, &mut T, et tout type qui implémente Drop.

let s1 = String::from("hello");
let s2 = s1.clone();              // nouvelle allocation, copie des octets
println!("{s1} {s2}");            // les deux sont valides

.clone() est visible dans le code : c'est voulu, car une copie de données sur le tas a un coût.

fn longueur(s: &String) -> usize {
    s.len()
}                                 // s est une référence : rien n'est libéré

fn main() {
    let texte = String::from("hello");
    let n = longueur(&texte);     // on prête texte
    println!("{texte} : {n}");    // texte est toujours là
}

Une référence &T est un pointeur vers une valeur possédée par quelqu'un d'autre. Elle ne la libère jamais.

let s = String::from("hello");
let r1 = &s;
let r2 = &s;
let r3 = &s;
println!("{r1} {r2} {r3}");       // autant de lecteurs que l'on veut

fn modifier(s: &String) {
    // s.push('!');               // ERREUR : cannot borrow `*s` as mutable
}

let x = 5;
let r = &x;
assert_eq!(*r, 5);                // * pour lire la valeur pointée
assert_eq!(r.pow(2), 25);         // les méthodes déréférencent automatiquement
let somme = r + 1;                // les opérateurs aussi, pour les nombres

fn ajouter_monde(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut texte = String::from("hello");   // la variable doit être mut
    ajouter_monde(&mut texte);               // on prête en écriture
    println!("{texte}");                     // hello, world
}

Il faut mut à deux endroits : sur la variable (let mut) et sur l'emprunt (&mut).

fn doubler(n: &mut i32) {
    *n *= 2;                    // * obligatoire pour affecter la valeur pointée
}

let mut x = 5;
doubler(&mut x);
assert_eq!(x, 10);

let mut s = String::from("a");
let r1 = &mut s;
// let r2 = &mut s;             // ERREUR E0499 : two mutable borrows
r1.push('b');

À quoi ça sert : si deux références pouvaient modifier la même valeur, l'une pourrait réallouer le contenu pendant que l'autre le lit. C'est la cause des « data races » entre threads ; Rust les rend impossibles à la compilation.

let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
println!("{r1} {r2}");           // dernière utilisation de r1 et r2

let r3 = &mut s;                 // OK : r1 et r2 ne sont plus utilisées
r3.push('!');

Un emprunt ne dure pas jusqu'à la fin du bloc mais jusqu'à sa dernière utilisation (règle appelée NLL, Non-Lexical Lifetimes). Réordonner les lignes suffit souvent à corriger une erreur.

let mut v = vec![1, 2, 3];
let premier = &v[0];             // v est prêtée en lecture
// v.push(4);                    // ERREUR E0502 : v ne peut pas être modifiée
println!("{premier}");
v.push(4);                       // OK : premier ne sert plus

push peut réallouer le tableau : premier pointerait alors vers une mémoire libérée.

// fn creer() -> &String {
//     let s = String::from("hello");
//     &s                        // ERREUR : s est libérée à la fin de la fonction
// }

fn creer() -> String {            // correction : renvoyer la valeur elle-même
    String::from("hello")
}

fn ajouter(v: &mut Vec<i32>) {
    v.push(1);
}

let mut v = vec![];
let r = &mut v;
ajouter(r);                       // réemprunt temporaire de *r
ajouter(r);                       // r est toujours utilisable
r.push(2);

Passer une &mut à une fonction ne la déplace pas : Rust crée un réemprunt (&mut *r) qui dure le temps de l'appel.

let mut v: Vec<usize> = vec![1, 2, 3];
v.push(v.len());                  // OK : v.len() est évalué avant l'emprunt mutable de push

struct Jeu { joueurs: Vec<String>, scores: Vec<u32> }

let mut j = Jeu { joueurs: vec!["a".into()], scores: vec![0] };
let joueurs = &j.joueurs;         // emprunt de j.joueurs seulement
j.scores.push(10);                // OK : champ différent
println!("{joueurs:?}");

Le compilateur suit les emprunts champ par champ.

impl Jeu {
    fn joueurs(&self) -> &Vec<String> { &self.joueurs }
    fn ajouter_score(&mut self, s: u32) { self.scores.push(s); }
}

let joueurs = j.joueurs();        // emprunte TOUT j
// j.ajouter_score(10);           // ERREUR : j est déjà empruntée
println!("{joueurs:?}");

Une méthode &self emprunte toute la struct : le compilateur ne regarde pas ce que la méthode lit vraiment. Trois corrections :

// 1. Accéder aux champs directement (dans le module qui les voit)
let joueurs = &j.joueurs;
j.scores.push(10);

// 2. Copier ce dont on a besoin avant
let nb = j.joueurs().len();
j.ajouter_score(10);

// 3. Une méthode qui rend les deux parties en même temps
impl Jeu {
    fn parties(&mut self) -> (&Vec<String>, &mut Vec<u32>) {
        (&self.joueurs, &mut self.scores)
    }
}
let (joueurs, scores) = j.parties();
scores.push(10);

let s = String::from("hello world");
let hello: &str = &s[0..5];
let world: &str = &s[6..];
let tout: &str = &s[..];
let litteral: &str = "texte";     // un littéral est déjà une &str

Les index sont en octets : couper au milieu d'un caractère accentué fait paniquer.

let mot = "café";
// let x = &mot[0..4];            // panique : 'é' occupe les octets 3 et 4
let x = mot.get(0..4);            // None, sans panique
let premiers: String = mot.chars().take(3).collect();   // "caf", en caractères

let v = vec![1, 2, 3, 4, 5];
let milieu: &[i32] = &v[1..4];    // [2, 3, 4]
let t = [10, 20, 30];
let debut = &t[..2];

let (a, b) = v.split_at(2);       // deux tranches : [1, 2] et [3, 4, 5]

fn premier_mot(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

let mut s = String::from("hello world");
let mot = premier_mot(&s);
// s.clear();                     // ERREUR : mot emprunte encore s
println!("{mot}");

Si la fonction renvoyait un index (usize), rien n'empêcherait de vider s puis d'utiliser l'index devenu faux. La tranche lie le résultat à la donnée.

// 1. Prend la String : l'appelant la perd
fn majuscule_v1(s: String) -> String { s.to_uppercase() }

// 2. Emprunte une &String : n'accepte que des String
fn majuscule_v2(s: &String) -> String { s.to_uppercase() }

// 3. Emprunte une &str : accepte String, &str, littéraux, tranches
fn majuscule_v3(s: &str) -> String { s.to_uppercase() }

// 4. Modifie sur place : pas de nouvelle allocation
fn majuscule_v4(s: &mut String) { s.make_ascii_uppercase(); }

fn main() {
    let mut a = String::from("abc");
    majuscule_v3(&a);
    majuscule_v3("littéral");
    majuscule_v4(&mut a);
    let b = majuscule_v1(a);       // a n'est plus utilisable
}

let s = String::from("a");
let t = s;
// println!("{s}");

Corrections :

let t = s.clone();      // 1. copier
let t = &s;             // 2. emprunter
// 3. utiliser s avant de la déplacer
println!("{s}");
let t = s;

let mut v = vec![1, 2];
let a = &mut v[0];
// let b = &mut v[1];
// *a += *b;

Corrections :

// 1. split_at_mut : deux tranches mutables qui ne se recouvrent pas
let (gauche, droite) = v.split_at_mut(1);
gauche[0] += droite[0];

// 2. Passer par les index
let b = v[1];
v[0] += b;

// 3. swap pour échanger
v.swap(0, 1);

let mut v = vec![1, 2, 3];
// for x in &v {
//     if *x == 2 { v.push(4); }
// }

Corrections :

// 1. Décider d'abord, modifier ensuite
let contient = v.contains(&2);
if contient { v.push(4); }

// 2. Collecter les ajouts puis les appliquer
let ajouts: Vec<i32> = v.iter().filter(|&&x| x == 2).map(|_| 4).collect();
v.extend(ajouts);

// 3. Boucler sur les index quand la modification dépend de l'élément courant
for i in 0..v.len() {
    if v[i] == 2 { v[i] = 20; }
}

let s = String::from("a");
let r = &s;
// drop(s);
println!("{r}");

Correction : terminer l'utilisation de l'emprunt avant de déplacer (println! avant drop), ou cloner.

struct Boite { contenu: String }

fn vider(b: &mut Boite) -> String {
    // b.contenu                  // ERREUR : cannot move out of `b.contenu` which is behind a mutable reference
    std::mem::take(&mut b.contenu)    // prend la valeur, laisse String::new()
}

fn lire(b: &Boite) -> String {
    b.contenu.clone()             // ou renvoyer &str : &b.contenu
}

Avec une Option : opt.take() prend la valeur et laisse None.

let r;
{
    let x = 5;
    r = &x;
}                                 // x libérée
// println!("{r}");               // ERREUR : `x` does not live long enough

Correction : déclarer x dans la même portée que r (ou avant), ou stocker la valeur elle-même plutôt qu'une référence.

// fn plus_long(a: &str, b: &str) -> &str { if a.len() > b.len() { a } else { b } }
fn plus_long<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() { a } else { b }
}

Quand une fonction renvoie une référence qui peut venir de plusieurs paramètres, il faut dire de quel paramètre elle dépend. Détails dans le cours lifetimes.

use std::mem;

let mut a = String::from("ancien");
let ancien = mem::replace(&mut a, String::from("nouveau"));
let vide = mem::take(&mut a);          // a devient ""
let mut x = 1;
let mut y = 2;
mem::swap(&mut x, &mut y);

fn main() {
    let mut liste = vec![1, 2, 3];
    let premier = &liste[0];
    liste.push(4);
    println!("{premier}");
}

// Solution 1 : copier l'entier (Copy, gratuit)
let premier = liste[0];
liste.push(4);
println!("{premier}");

// Solution 2 : réordonner
let premier = &liste[0];
println!("{premier}");
liste.push(4);

struct Session { jeton: Option<String> }

// Écris `fn deconnecter(s: &mut Session) -> Option<String>` qui renvoie le jeton et le retire.

// Solution :
fn deconnecter(s: &mut Session) -> Option<String> {
    s.jeton.take()
}

let t = s;              // move (type non Copy)
let t = s.clone();      // copie explicite
let r = &s;             // emprunt en lecture (plusieurs possibles)
let r = &mut s;         // emprunt en écriture (un seul, rien d'autre en même temps)
*r = valeur;            // écrire à travers &mut
drop(s);                // libérer maintenant
std::mem::take(&mut x)  // prendre en laissant Default
opt.take()              // prendre en laissant None
v.split_at_mut(i)       // deux &mut disjoints