---
title: "Emprunts mutables et immutables : les deux règles"
description: "Les deux règles d'emprunt, pourquoi l'exclusivité est celle qui compte, et ce que le borrow checker rejette réellement."
url: "https://mayorana.ch/fr/blog/borrowing-rules-rust-fr"
language: "fr"
date: "2025-11-29"
author: "Mohamed Bennekrouf"
tags:
- "rust"
- "memory"
- "borrowing"
- "ownership"
- "safety"
en_version: "https://mayorana.ch/en/blog/borrowing-rules-rust.md"
---
# Emprunts mutables et immutables : les deux règles
Les règles de borrowing de Rust, appliquées par le borrow checker au moment de la compilation, assurent la memory safety et préviennent les [data races](https://mayorana.ch/fr/blog/ownership-safety-rust-fr) sans overhead runtime. Ces règles gouvernent comment les données peuvent être accédées via des références, distinguant entre emprunts mutables (`&mut T`) et immutables (`&T`).
## Les règles de Borrowing (Appliquées par le Compiler)
1. **Soit Un Emprunt Mutable (`&mut T`) SOIT Plusieurs Emprunts Immutables (`&T`)** :
- Tu peux avoir :
- **Une référence mutable** (`&mut T`), OU
- **N'importe quel nombre de références immutables** (`&T`).
- Jamais les deux en même temps pour les mêmes données.
2. **Les Références Doivent Toujours Être Valides (Pas de [Dangling Pointers](https://mayorana.ch/fr/blog/dangling-pointer-rust-fr))** :
- Les références empruntées ne peuvent pas survivre aux données qu'elles pointent, appliqué par le système de lifetime de Rust.
## Emprunts immutables (`&T`)
- **Accès read-only** : Ne peut pas modifier les données.
- **Plusieurs autorisés** : Sûr pour lectures concurrentes, car aucune modification ne peut survenir.
**Exemple** :
```rust
let x = 42;
let r1 = &x; // OK: Borrowing immutable
let r2 = &x; // OK: Autre borrow immutable
println!("{}, {}", r1, r2); // Fonctionne bien
```
## Emprunts mutables (`&mut T`)
- **Accès exclusif** : Permet modification des données.
- **Aucun autre emprunt autorisé** : Aucun `&T` ou `&mut T` additionnel ne peut coexister pour les mêmes données.
**Exemple** :
```rust
let mut x = 42;
let r1 = &mut x; // OK: Emprunt mutable
*r1 += 1; // Peut modifier
// let r2 = &x; // ERREUR: Cannot borrow `x` as immutable while mutable borrow exists
```
## Ce que le compilateur rejette
1. **Chevauchement Mutable + Immutable** :
```rust
let mut data = 10;
let r1 = &data; // Borrowing immutable
let r2 = &mut data; // ERREUR: Cannot borrow as mutable while borrowed as immutable
```
2. **Emprunts Mutables Multiples** :
```rust
let mut s = String::new();
let r1 = &mut s;
let r2 = &mut s; // ERREUR: Second mutable borrow
```
3. **Références Dangereuses** :
```rust
fn dangling() -> &String {
let s = String::from("oops");
&s // ERREUR: `s` meurt ici, référence pendrait
}
```
Ce que le checker compare n'est pas *l'existence* des deux emprunts, mais le chevauchement de leurs durées de vie. La durée d'un emprunt se termine à sa **dernière utilisation**, pas à la fin du bloc :
## Pourquoi ces règles Comptent
- **Prévient les Data Races** : En interdisant l'accès mutable concurrent, Rust assure la thread safety par défaut.
- **Assure Memory Safety** : Pas de dangling pointers ou invalidation d'iterator, car le borrow checker applique les références valides.
## Les deux règles
**Emprunts immutables (`&T`)** :
- Plusieurs autorisés, mais pas de mutation.
**Emprunts mutables (`&mut T`)** :
- Un seul autorisé, accès exclusif.
**Violations attrapées au moment de la compilation** : Pas d'overhead runtime.
**Impact Réel** : Ces règles permettent la concurrence sans peur, comme vu dans les crates comme `Rayon` pour l'itération parallèle.
Écris une fonction qui prend `&mut T` et appelle-la deux fois sur la même valeur. Ça compile —
mais seulement parce que le premier emprunt se termine à la fin de l'appel. Garde cet emprunt
dans une variable qui traverse les deux appels et tu verras la vraie erreur.