Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Rust

Partie 3 sur 4

Niveau de lecture :

6La propriété

6.1Trois règles

La notion centrale de Rust est la propriété (en anglais ownership). Elle repose sur trois règles :

  1. chaque valeur a un propriétaire, une variable ;
  2. il n’y a qu’un seul propriétaire à la fois ;
  3. quand le propriétaire sort de sa portée, c’est-à-dire à la fin du bloc où il a été déclaré, la valeur est détruite et sa mémoire libérée.

La troisième règle remplace à la fois le free du C, que l’on oublie ou que l’on appelle deux fois, et le ramasse-miettes des autres langages : le compilateur insère lui-même la libération au bon endroit, exactement une fois.

6.2Le déplacement

Que se passe-t-il quand on affecte une variable à une autre ? Pour une chaîne de type String, dont le contenu est rangé dans le tas, la zone de mémoire où les programmes réservent des données de taille variable, Rust ne copie pas le contenu : il déplace la propriété (figure 1). L’ancienne variable devient inutilisable :

let a = String::from("salut");
let b = a;              // la propriété passe à b
println!("{a}");        // erreur de compilation : a a été déplacée
1. CRÉATION let a = String::from("salut"); pile tas a s a l u t « salut », un seul propriétaire à la fois 2. DÉPLACEMENT let b = a; pile tas a inutilisable b s a l u t « salut », un seul propriétaire à la fois Quand le propriétaire sort de la portée, la mémoire est libérée automatiquement, une seule fois.
Figure 1. Le déplacement : la propriété du texte passe de a à b, et a ne peut plus être utilisée.

Le compilateur répond par un message précis, error[E0382]: borrow of moved value: `a`, qui indique la ligne du déplacement. En C++, l’équivalent aurait laissé deux variables désigner la même zone, et le programme l’aurait libérée deux fois. Pour obtenir réellement deux copies, il faut le demander explicitement avec a.clone(), ce qui rend visible le coût de la copie.

Les types simples, dont la taille est fixe et connue, comme les entiers, les nombres à virgule, les booléens ou les caractères, sont simplement copiés : après let y = x;, les deux variables restent utilisables. On dit qu’ils implémentent le trait Copy. Passer une valeur à une fonction obéit aux mêmes règles : une String passée « par valeur » est déplacée dans la fonction, et l’appelant ne peut plus s’en servir.

7Les emprunts

7.1Prêter sans céder

Céder la propriété à chaque appel de fonction serait vite incommode. Rust permet donc d’emprunter une valeur, par une référence, notée & : la fonction peut lire la valeur, mais celle-ci reste à son propriétaire.

fn longueur(s: &str) -> usize {
    s.len()
}

let nom = String::from("Ada");
let n = longueur(&nom);    // on prête nom, sans le céder
println!("{nom} a {n} lettres");

7.2La règle d’or

Les emprunts obéissent à une règle simple, vérifiée par une partie du compilateur appelée le vérificateur d’emprunts (en anglais borrow checker) : à un instant donné, une valeur peut avoir soit plusieurs emprunts en lecture (&T), soit un seul emprunt en écriture (&mut T), jamais les deux à la fois (figure 2). C’est le principe « plusieurs lecteurs ou un seul écrivain », bien connu des bases de données, mais appliqué ici à chaque variable, et vérifié avant l’exécution.

PLUSIEURS LECTEURS &T : emprunts partagés donnée &r1 &r2 &r3 lecture seule : autorisé OU UN SEUL ÉCRIVAIN &mut T : emprunt exclusif donnée &mut w &r un autre accès en même temps : refusé Le compilateur vérifie ces règles avant l’exécution : pas de modification pendant une lecture.
Figure 2. Plusieurs lecteurs ou un seul écrivain : la règle d’or des emprunts.

Cette règle peut sembler arbitraire ; elle évite pourtant une erreur classique. Dans l’exemple suivant, on garde une référence vers le premier élément d’une liste, puis on ajoute un élément :

let mut liste = vec![1, 2, 3];
let premier = &liste[0];    // emprunt en lecture
liste.push(4);              // refusé : modification pendant l'emprunt
println!("{premier}");

Pourquoi refuser ? Parce qu’en ajoutant un élément, la liste peut manquer de place et être déplacée ailleurs en mémoire. La référence premier désignerait alors une zone libérée : c’est exactement l’utilisation après libération qui provoque tant de failles en C++. Rust la refuse avant même l’exécution.

7.3Les durées de vie

Le compilateur vérifie aussi qu’une référence ne survit jamais à la valeur qu’elle désigne. Il suit pour cela la durée de vie (en anglais lifetime) de chaque référence, c’est-à-dire la portion du programme où elle est valable. Le plus souvent, il la déduit seul. Dans certains cas ambigus, par exemple une fonction qui reçoit deux références et en renvoie une, il faut l’indiquer par une annotation, notée avec une apostrophe :

fn plus_long<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() { x } else { y }
}

L’annotation 'a signifie : le résultat est valable tant que les deux paramètres le sont. Les durées de vie sont la partie la plus déroutante de Rust pour les débutants ; on les rencontre surtout en écrivant des bibliothèques, et les messages d’erreur du compilateur, réputés pour leur clarté, proposent souvent la correction.

La solidité de ces règles a été étudiée par des chercheurs : le projet RustBelt, mené notamment à l’institut Max-Planck pour les systèmes logiciels, a démontré mathématiquement en 2018 que le cœur du système de types de Rust garantit bien la sûreté de la mémoire, y compris en présence de bibliothèques qui utilisent du code non vérifié, à condition que celles-ci respectent leurs propres contrats.

Pour s’exercer

Exercice 5 : la liste empruntée

Reprenez l’exemple de la section 7.2, où l’on ajoute un élément à une liste pendant qu’on en garde une référence. Proposez deux façons de corriger le programme.

Voir la réponse

Première façon : utiliser la référence avant de modifier la liste, en déplaçant le println! avant liste.push(4) ; l’emprunt se termine après sa dernière utilisation, et la modification devient permise. Seconde façon : ne pas garder de référence mais une copie de la valeur, let premier = liste[0]; ; un i32 se copie, et la liste peut ensuite être modifiée librement. Dans les deux cas, plus aucune référence ne risque de désigner une zone déplacée.

8La concurrence sans crainte

Les processeurs actuels ont de nombreux cœurs ; pour en tirer parti, un programme lance plusieurs fils d’exécution (en anglais threads) qui travaillent en parallèle (voir les processus). Le danger est la course de données. Les règles d’emprunt s’appliquent aussi entre fils d’exécution : une donnée ne peut être modifiée par un fil que si aucun autre n’y a accès. Pour partager une donnée modifiable, il faut l’envelopper dans des types qui organisent l’accès, comme Mutex, un verrou qui n’autorise qu’un fil à la fois, et Arc, un compteur de références partagé entre fils :

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let compteur = Arc::new(Mutex::new(0));
    let mut fils = Vec::new();
    for _ in 0..10 {
        let c = Arc::clone(&compteur);
        fils.push(thread::spawn(move || {
            *c.lock().unwrap() += 1;      // accès sous verrou
        }));
    }
    for f in fils {
        f.join().unwrap();
    }
    println!("Total : {}", *compteur.lock().unwrap());   // 10
}

Si l’on oublie le verrou, le programme ne compile pas : deux traits, Send et Sync, indiquent au compilateur quels types peuvent être transmis ou partagés entre fils, et il refuse les autres. La communauté parle de « concurrence sans crainte » (en anglais fearless concurrency). Les verrous mal ordonnés, qui bloquent mutuellement deux fils, restent en revanche possibles.

Pour les serveurs qui gèrent des milliers de connexions simultanées, Rust propose aussi la programmation asynchrone, avec les mots-clés async et await : une tâche qui attend une réponse du réseau libère le processeur pour les autres. Le langage fournit la syntaxe, et des bibliothèques comme Tokio fournissent le moteur qui fait tourner ces tâches.

Pour s’exercer

Exercice 6 : le serveur qui plante

Un service Web en Rust lit l’âge d’un client dans une requête avec let age: u8 = texte.parse().unwrap();. Un utilisateur envoie la valeur « abc ». Que se passe-t-il ? Est-ce une faille de sécurité ? Comment corriger ?

Voir la réponse

parse renvoie une erreur, et unwrap déclenche une panique. Selon la façon dont le service est construit, la requête échoue ou le programme entier s’arrête. Il n’y a pas de corruption de la mémoire, mais un attaquant peut provoquer à volonté des arrêts : c’est un déni de service (voir le déni de service). La correction consiste à traiter l’erreur : match texte.parse::<u8>() { Ok(age) => …, Err(_) => return réponse 400 }, c’est-à-dire renvoyer une erreur « requête invalide » à l’utilisateur. L’outil clippy peut être configuré pour interdire unwrap dans le code de production.