Smart pointers

let b = Box::new(String::from("abc"));
let n = b.len();               // méthode de String, appelée sur une Box<String>
let s: &str = &b;              // &Box<String> devient &String puis &str

Deref dit « je peux être vu comme une référence vers Target ». Le compilateur insère alors les conversions tout seul (deref coercion), autant de fois que nécessaire.

use std::ops::Deref;

struct Enveloppe<T> {
    valeur: T,
    lectures: std::cell::Cell<u32>,
}

impl<T> Deref for Enveloppe<T> {
    type Target = T;
    fn deref(&self) -> &T {
        self.lectures.set(self.lectures.get() + 1);
        &self.valeur
    }
}

let e = Enveloppe { valeur: vec![1, 2, 3], lectures: std::cell::Cell::new(0) };
println!("{}", e.len());       // méthode de Vec

DerefMut fait la même chose pour &mut.

struct Connexion { nom: String }

impl Drop for Connexion {
    fn drop(&mut self) {
        println!("fermeture de {}", self.nom);
    }
}

fn main() {
    let _c = Connexion { nom: "base".into() };
    println!("travail");
}
// travail
// fermeture de base

drop est appelé automatiquement quand la valeur sort de portée, même si le programme panique (déroulement de pile). Il sert à libérer ce que Rust ne connaît pas : fichier, verrou, connexion, fichier temporaire, compteur à décrémenter.

struct Nom(&'static str);
impl Drop for Nom {
    fn drop(&mut self) { println!("drop {}", self.0); }
}

struct Paire { a: Nom, b: Nom }

fn main() {
    let _x = Nom("x");
    let _y = Nom("y");
    let _p = Paire { a: Nom("a"), b: Nom("b") };
}
// drop a, drop b      (champs : ordre de déclaration, après le drop de Paire elle-même)
// drop y, drop x      (variables : ordre inverse de déclaration)

let c = Connexion { nom: "base".into() };
// c.drop();               // ERREUR E0040 : explicit use of destructor method
drop(c);                   // OK : std::mem::drop prend la valeur

On ne peut pas appeler la méthode drop soi-même (elle serait rappelée à la fin du bloc, soit deux libérations). drop(c) déplace c dans une fonction vide qui la libère.

use std::sync::Mutex;

let m = Mutex::new(0);
{
    let mut garde = m.lock().unwrap();   // verrou pris
    *garde += 1;
}                                        // garde libérée : verrou relâché

let mut garde = m.lock().unwrap();
*garde += 1;
drop(garde);                             // relâcher avant une longue opération
// longue_operation();

Le verrou d'un Mutex est un MutexGuard dont le Drop relâche le verrou. Garder un garde plus longtemps que nécessaire bloque tous les autres threads.

struct ALaSortie<F: FnMut()>(F);

impl<F: FnMut()> Drop for ALaSortie<F> {
    fn drop(&mut self) { (self.0)(); }
}

fn traiter(echec: bool) -> Result<(), String> {
    let _nettoyage = ALaSortie(|| println!("fichier temporaire supprimé"));
    if echec {
        return Err("échec au milieu".into());   // le nettoyage s'exécute quand même
    }
    Ok(())
}

let a = String::from("partagée");
let liste1 = vec![a];
// let liste2 = vec![a];      // ERREUR : a a déjà été déplacée

Parfois une valeur doit appartenir à plusieurs structures à la fois (un nœud référencé par plusieurs parents, une configuration partagée par plusieurs composants).

use std::rc::Rc;

let a = Rc::new(String::from("partagée"));
let b = Rc::clone(&a);         // même String, compteur à 2
let c = a.clone();             // même chose, écriture plus courte
println!("{}", Rc::strong_count(&a));   // 3
drop(b);
println!("{}", Rc::strong_count(&a));   // 2
// la String est libérée quand le dernier Rc disparaît

Rc::clone ne copie pas la valeur : il augmente un compteur. Rc::clone(&a) est préféré à a.clone() dans la plupart des codes, pour qu'on voie au premier coup d'œil qu'il ne s'agit pas d'une copie coûteuse.

let r = Rc::new(vec![1, 2]);
// r.push(3);                 // ERREUR : cannot borrow data in an `Rc` as mutable

Plusieurs propriétaires qui pourraient tous modifier : c'est exactement ce que les règles d'emprunt interdisent. Pour modifier, il faut une mutabilité interne (section 8).

let r = Rc::new(String::from("x"));
match Rc::try_unwrap(r) {
    Ok(s) => println!("seul propriétaire : {s}"),     // possible si le compteur vaut 1
    Err(r) => println!("encore partagée"),
}

use std::sync::Arc;
use std::thread;

let config = Arc::new(vec!["a", "b"]);
let mut taches = Vec::new();
for i in 0..3 {
    let c = Arc::clone(&config);
    taches.push(thread::spawn(move || println!("{i} : {:?}", c)));
}
for t in taches {
    t.join().unwrap();
}

use std::cell::Cell;

struct Compteur {
    appels: Cell<u32>,
}

impl Compteur {
    fn compter(&self) {                        // &self, pas &mut self
        self.appels.set(self.appels.get() + 1);
    }
}

let c = Compteur { appels: Cell::new(0) };
c.compter();
c.compter();
println!("{}", c.appels.get());   // 2

use std::cell::RefCell;

let v = RefCell::new(vec![1, 2]);
v.borrow_mut().push(3);                  // emprunt mutable temporaire
println!("{:?}", v.borrow());            // emprunt partagé temporaire

RefCell applique les mêmes règles d'emprunt (une écriture ou plusieurs lectures), mais à l'exécution au lieu de la compilation.

let v = RefCell::new(vec![1]);
let lecture = v.borrow();
// let ecriture = v.borrow_mut();       // PANIQUE : already borrowed: BorrowMutError
drop(lecture);
let ecriture = v.borrow_mut();           // OK

match v.try_borrow_mut() {
    Ok(mut e) => e.push(4),
    Err(_) => println!("déjà empruntée ailleurs"),
}

let donnees = RefCell::new(vec![1, 2, 3]);

// Risqué : l'emprunt vit pendant tout le bloc
{
    let lecture = donnees.borrow();
    for x in lecture.iter() {
        // donnees.borrow_mut().push(*x);   // panique
    }
}

// Sûr : copier ce dont on a besoin, puis relâcher
let copie: Vec<i32> = donnees.borrow().clone();
for x in copie {
    donnees.borrow_mut().push(x);
}

Les emprunts de RefCell (Ref, RefMut) se libèrent à la fin de leur portée, comme un verrou.

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Compte { solde: i64 }

let compte = Rc::new(RefCell::new(Compte { solde: 100 }));
let titulaire = Rc::clone(&compte);
let banque = Rc::clone(&compte);

titulaire.borrow_mut().solde -= 30;
banque.borrow_mut().solde += 5;
println!("{:?}", compte.borrow());      // Compte { solde: 75 }

use std::cell::RefCell;
use std::rc::Rc;

struct Noeud {
    suivant: RefCell<Option<Rc<Noeud>>>,
}

let a = Rc::new(Noeud { suivant: RefCell::new(None) });
let b = Rc::new(Noeud { suivant: RefCell::new(Some(Rc::clone(&a))) });
*a.suivant.borrow_mut() = Some(Rc::clone(&b));    // a -> b -> a
// à la fin du bloc, chaque compteur reste à 1 : aucun des deux n'est jamais libéré

Rust empêche les accès invalides, pas les fuites : un cycle de Rc est sûr mais ne libère jamais sa mémoire.

use std::rc::{Rc, Weak};

let fort = Rc::new(5);
let faible: Weak<i32> = Rc::downgrade(&fort);

println!("{:?}", faible.upgrade());   // Some(5) : la valeur existe encore
drop(fort);
println!("{:?}", faible.upgrade());   // None : libérée

Un Weak ne compte pas pour la libération. upgrade() renvoie un Rc si la valeur existe encore, None sinon.

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct Noeud {
    valeur: i32,
    parent: RefCell<Weak<Noeud>>,          // faible : l'enfant ne retient pas le parent
    enfants: RefCell<Vec<Rc<Noeud>>>,      // fort : le parent retient ses enfants
}

let feuille = Rc::new(Noeud { valeur: 3, parent: RefCell::new(Weak::new()), enfants: RefCell::new(vec![]) });
let branche = Rc::new(Noeud {
    valeur: 5,
    parent: RefCell::new(Weak::new()),
    enfants: RefCell::new(vec![Rc::clone(&feuille)]),
});
*feuille.parent.borrow_mut() = Rc::downgrade(&branche);

let parent = feuille.parent.borrow().upgrade().map(|p| p.valeur);   // Some(5)

Règle : les liens qui vont vers le bas (propriétaire → possédé) sont forts, ceux qui remontent sont faibles.

use std::collections::HashMap;
use std::sync::{LazyLock, OnceLock};

// 1. LazyLock (Rust 1.80+) : la fonction d'initialisation est donnée à la déclaration
static PAYS: LazyLock<HashMap<&str, &str>> = LazyLock::new(|| {
    HashMap::from([("fr", "France"), ("be", "Belgique")])
});

// 2. OnceLock : la valeur est fixée plus tard, une seule fois
static CONFIG: OnceLock<String> = OnceLock::new();

fn initialiser(url: String) {
    CONFIG.set(url).expect("configuration déjà initialisée");
}

fn config() -> &'static str {
    CONFIG.get().map(String::as_str).unwrap_or("non configuré")
}

// 3. OnceLock avec get_or_init : calcul à la première demande, depuis n'importe où
fn regex_email() -> &'static regex::Regex {
    static R: OnceLock<regex::Regex> = OnceLock::new();
    R.get_or_init(|| regex::Regex::new(r"^[^@\s]+@[^@\s]+$").unwrap())
}

fn main() {
    println!("{}", PAYS["fr"]);
    initialiser("postgres://...".into());
    println!("{}", config());
}

Ces types remplacent les crates lazy_static et once_cell dans le code récent.

use std::cell::OnceCell;

struct Document {
    texte: String,
    nb_mots: OnceCell<usize>,          // calculé à la première demande, puis gardé
}

impl Document {
    fn nb_mots(&self) -> usize {
        *self.nb_mots.get_or_init(|| self.texte.split_whitespace().count())
    }
}

use std::rc::Rc;

let mut a = Rc::new(vec![1, 2, 3]);
let b = Rc::clone(&a);

Rc::make_mut(&mut a).push(4);      // a est partagé : la valeur est COPIÉE puis modifiée
println!("{:?} {:?}", a, b);       // [1, 2, 3, 4] [1, 2, 3]

Rc::make_mut(&mut a).push(5);      // a est maintenant seul : modifié sur place, sans copie

use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::{Rc, Weak};

// 1. Rc + RefCell + Weak : des pointeurs entre nœuds
struct Utilisateur1 {
    nom: String,
    suit: RefCell<Vec<Weak<Utilisateur1>>>,
}

// 2. Index dans un Vec : un seul propriétaire, des numéros comme liens
struct Reseau2 {
    noms: Vec<String>,
    suit: Vec<Vec<usize>>,          // suit[i] = index des personnes suivies par i
}

impl Reseau2 {
    fn ajouter(&mut self, nom: &str) -> usize {
        self.noms.push(nom.to_string());
        self.suit.push(Vec::new());
        self.noms.len() - 1
    }
    fn suivre(&mut self, qui: usize, cible: usize) {
        self.suit[qui].push(cible);
    }
}

// 3. Identifiants dans une HashMap : comme en base de données
struct Reseau3 {
    utilisateurs: HashMap<u64, String>,
    suit: HashMap<u64, Vec<u64>>,
}

impl Drop for T { fn drop(&mut self) { .. } }     drop(x)
impl Deref for T { type Target = U; fn deref(&self) -> &U { .. } }

Rc::new(v)   Rc::clone(&r)   Rc::strong_count(&r)   Rc::downgrade(&r)   Rc::try_unwrap(r)   Rc::make_mut(&mut r)
Arc::new(v)  Arc::clone(&a)
weak.upgrade()                                     // Option<Rc<T>>
Cell::new(v)   c.get()   c.set(v)   c.replace(v)   c.take()
RefCell::new(v)   r.borrow()   r.borrow_mut()   r.try_borrow_mut()
OnceLock::new()   o.set(v)   o.get()   o.get_or_init(|| v)
static X: LazyLock<T> = LazyLock::new(|| v);