Chapitre 04
Ownership, emprunts & lifetimes

1. Le problème que Rust résout

En C et en C++, la mémoire dynamique est votre responsabilité. Vous appelez malloc/free, new/delete, et vous devez le faire au bon moment, exactement une fois, dans tous les chemins d'exécution — y compris ceux qui lèvent une exception ou sortent d'une boucle par un return anticipé. Toute erreur produit un des classiques du domaine :

• Fuite mémoire : on oublie le free, la mémoire n'est jamais rendue.
• Double-free : on libère deux fois le même bloc, corruption du tas.
• Dangling pointer : on garde un pointeur vers une zone déjà libérée.
• Use-after-free : on lit ou écrit à travers ce pointeur — comportement indéfini.

Ces bugs sont particulièrement redoutables en robotique : ils sont non déterministes, se manifestent parfois après des heures de fonctionnement, et peuvent immobiliser un bras robotisé au pire moment. Le C++ moderne les atténue avec les smart pointers et le RAII, mais rien n'empêche à la compilation d'écrire un dangling reference.

Rust prend le problème à la racine : la sécurité mémoire est garantie à la compilation, sans ramasse-miettes (pas de garbage collector, donc pas de pauses imprévisibles — point crucial en temps réel). Le mécanisme central s'appelle l'ownership (la « possession »).

2. Les trois règles de l'ownership

Tout le modèle tient en trois règles, vérifiées par le compilateur :

1. Chaque valeur a un propriétaire (une variable).
2. Il ne peut y avoir qu'un seul propriétaire à la fois.
3. Quand le propriétaire sort du scope, la valeur est libérée automatiquement (drop).

fn main() {
    {
        let etat = String::from("robot en marche"); // `etat` devient propriétaire
        println!("{etat}");
    } // <- fin du scope : `drop` est appelé, la mémoire est rendue ici

    // `etat` n'existe plus, impossible de l'utiliser : erreur de compilation
}

3. Le déplacement (move) par défaut

Considérons ce code, qui paraîtrait anodin en C :

let a = String::from("capteur");
let b = a;          // move : la propriété de la chaîne passe de `a` à `b`
// println!("{a}"); // ERREUR : `a` a été déplacé, il n'est plus valide

En C++, b = a aurait fait une copie profonde (ou un move explicite avec std::move). En Rust, l'affectation d'une valeur possédée est un déplacement : la ressource n'est pas copiée, mais transférée. L'ancien propriétaire a est invalidé à la compilation. Résultat : impossible d'avoir deux variables qui croient posséder la même mémoire — donc pas de double-free.

Types Copy : les scalaires font exception

Les types simples stockés entièrement sur la pile (entiers, flottants, bool, char, et les tuples de ces types) implémentent le trait Copy. Pour eux, l'affectation duplique la valeur au lieu de la déplacer, car la copie est triviale et sans ressource à libérer.

let x: i32 = 42;
let y = x;      // copie : `x` reste utilisable
println!("{x} et {y}"); // OK : 42 et 42

let v = vec![1.0_f64, 2.0, 3.0];
let w = v;      // move : `v` n'est plus valide (Vec possède de la mémoire sur le tas)
// println!("{v:?}"); // ERREUR

4. clone() : la copie explicite (et son coût)

Quand vous voulez réellement une copie indépendante d'une valeur possédée, vous l'écrivez explicitement avec clone(). Le mot est volontairement visible dans le code : une copie profonde a un coût, et Rust veut que ce coût soit lisible.

let a = String::from("trajectoire");
let b = a.clone();  // copie profonde : deux chaînes indépendantes existent
println!("{a} / {b}"); // OK, les deux sont valides

5. Les emprunts (borrowing)

Déplacer la propriété à chaque fois qu'on veut lire une valeur serait ingérable. La solution est l'emprunt : on prête une référence sans céder la propriété. Deux formes :

• &T — emprunt partagé (lecture seule). On peut en avoir plusieurs simultanément.
• &mut T — emprunt mutable exclusif (lecture/écriture). Un seul à la fois.

La règle fondamentale du borrow checker, à tout instant, pour une valeur donnée :

Soit N lecteurs (&T), soit 1 écrivain (&mut T), jamais les deux en même temps.

fn afficher(v: &Vec<f64>) {          // emprunt partagé : on lit seulement
    println!("longueur = {}", v.len());
}

fn doubler(v: &mut Vec<f64>) {        // emprunt exclusif : on modifie
    for x in v.iter_mut() {
        *x *= 2.0;
    }
}

fn main() {
    let mut etat = vec![1.0, 2.0, 3.0];

    afficher(&etat);        // prêt en lecture, `etat` reste propriétaire
    doubler(&mut etat);     // prêt en écriture (exclusif)
    afficher(&etat);        // le vecteur vaut maintenant [2.0, 4.0, 6.0]
}

Cette règle « N lecteurs XOR 1 écrivain » est ce qui élimine à la compilation les data races et les invalidations d'itérateur (le fameux bug C++ où l'on modifie un std::vector pendant qu'on le parcourt).

6. Pourquoi c'est décisif pour la robotique

Imaginez une boucle de contrôle qui, à chaque itération, lit un vecteur d'état de plusieurs centaines de composantes (positions articulaires, vitesses, forces). En le passant par emprunt &Vec<f64> ou, mieux, par tranche &[f64], vous transmettez juste un pointeur + une longueur :

• Zéro copie — pas d'allocation, pas de recopie, coût constant et prévisible.
• Zéro dangling — le compilateur garantit que la référence ne survit pas à l'état.
• Zéro data race — le partage lecture/écriture est contrôlé statiquement.

/// Norme euclidienne d'un vecteur d'état, sans le copier.
fn norme(v: &[f64]) -> f64 {
    v.iter().map(|x| x * x).sum::<f64>().sqrt()
}

fn boucle_controle(etat: &[f64]) {
    // À 1 kHz, cet appel ne coûte rien de plus qu'un passage de pointeur.
    let e = norme(etat);
    println!("erreur = {e:.3}");
}

7. Notions de lifetimes

Une lifetime (durée de vie) est la portée pendant laquelle une référence reste valide. Le compilateur les suit toujours en interne ; la plupart du temps il les infère pour vous (on parle d'élision), et vous n'écrivez rien. Les annotations explicites, notées 'a, n'apparaissent que lorsque le compilateur ne peut pas deviner seul la relation entre les durées de vie — typiquement quand une fonction renvoie une référence.

/// Renvoie une référence vers le plus grand des deux flottants.
/// `'a` dit : « le résultat vit aussi longtemps que le PLUS COURT
/// des deux emprunts d'entrée ». C'est une promesse vérifiée à la compilation.
fn plus_grand<'a>(a: &'a f64, b: &'a f64) -> &'a f64 {
    if a > b { a } else { b }
}

fn main() {
    let x = 3.0;
    let y = 7.0;
    let m = plus_grand(&x, &y); // `m` emprunte `x` ou `y`
    println!("max = {m}");         // OK tant que x et y sont vivants
}

Les lifetimes ne changent rien à l'exécution : elles ne coûtent rien et ne modifient pas le code généré. Ce sont uniquement des annotations qui permettent au borrow checker de prouver qu'aucune référence ne pointe vers de la mémoire libérée. C'est la garantie « pas de dangling reference » rendue explicite.

// Ce que Rust REFUSE de compiler — et heureusement :
fn dangling() -> &f64 {
    let local = 42.0;
    &local            // ERREUR : `local` est libéré à la fin de la fonction
}                     // on retournerait un pointeur pendouillant, comme en C

Exercices

fn main() {
    let mut v = vec![10.0, 20.0, 30.0];
    let premier = &v[0];      // emprunt partagé
    v.push(40.0);             // emprunt mutable pendant que `premier` vit
    println!("{premier}");
}

fn main() {
    let mut v = vec![10.0, 20.0, 30.0];
    let premier = v[0];       // f64 est Copy : on copie la valeur, pas d'emprunt persistant
    v.push(40.0);             // plus aucun emprunt partagé en vie : OK
    println!("{premier}");    // affiche 10
}

fn norme(v: &[f64]) -> f64 {
    v.iter()
     .map(|x| x * x)   // chaque composante au carré
     .sum::<f64>()      // somme des carrés
     .sqrt()           // racine
}

fn main() {
    let etat = vec![3.0, 4.0];
    println!("{}", norme(&etat)); // 5.0
    println!("{}", norme(&etat)); // OK : `etat` n'a jamais été déplacé, on peut ré-emprunter
}

fn saturer(v: &mut [f64], limite: f64) {
    for x in v.iter_mut() {           // itération mutable : `x` est un &mut f64
        *x = x.clamp(-limite, limite); // clamp borne la valeur
    }
}

fn main() {
    let mut commandes = vec![0.5, -3.0, 2.2, -0.1];
    saturer(&mut commandes, 1.0);
    println!("{commandes:?}"); // [0.5, -1.0, 1.0, -0.1]
}

fn main() {
    let trajectoire = String::from("A -> B -> C");
    let copie = trajectoire;                 // (1)
    println!("origine : {trajectoire}");     // (2)
    println!("copie   : {copie}");
}

// (a) On veut deux chaînes indépendantes : copie explicite
let copie = trajectoire.clone();
println!("origine : {trajectoire}"); // OK, trajectoire est toujours propriétaire

// (b) On veut juste lire les deux fois la même donnée : emprunt
let copie = &trajectoire;            // emprunt partagé, pas de move
println!("origine : {trajectoire}");
println!("copie   : {copie}");

Récapitulatif