Références et emprunt expliqués
Découvrez les références et l’emprunt, qui permettent à plusieurs parties de votre code d’accéder aux données sans en prendre possession, en toute sécurité.
Références et emprunt expliqués est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.
Que sont les références ?
En Rust, les variables possèdent leurs données. Mais que faire si vous devez permettre à d’autres parties de votre code de consulter, voire de modifier ces données sans en prendre la propriété ?
C’est là qu’interviennent les références ! Une référence ressemble à un pointeur vers une valeur, mais elle est soumise à des règles strictes appliquées par le compilateur Rust.
Imaginez que vous regardiez quelque chose à travers une fenêtre au lieu de posséder l’objet lui-même.
Votre première référence
Nous créons une référence à l’aide de l’opérateur &. Celui-ci crée un pointeur qui ne possède pas la valeur. Voyons cela en pratique :
fn print_length(s: &String) {
println!("The length is: {}", s.len());
}
fn main() {
let message = String::from("Hello, CoddyKit!");
print_length(&message); // Pass a reference
println!("Original message still here: {}", message);
}Comprendre l’emprunt
Lorsque vous créez une référence vers une valeur, vous empruntez cette valeur. Le propriétaire la possède toujours, mais vous obtenez un accès temporaire.
- Prêter sans céder : vous pouvez utiliser les données empruntées.
- Aucun transfert de propriété : la variable d’origine possède toujours les données et les supprimera lorsqu’elle sortira de portée.
- La sécurité avant tout : les règles d’emprunt de Rust empêchent les erreurs de programmation courantes, comme les courses aux données.
Emprunts immuables : accès en lecture seule
Par défaut, les références en Rust sont immutables. Cela signifie que vous pouvez lire les données vers lesquelles elles pointent, mais pas les modifier.
Il s’agit d’une fonctionnalité essentielle pour la sécurité ! Si plusieurs parties de votre code disposent d’un accès en lecture seule, elles ne peuvent pas interférer accidentellement avec les données des autres.
Un emprunt immutable en pratique
Ici, la fonction calculate_sum reçoit une référence immutable vers un vecteur. Elle peut lire les éléments, mais ne peut ni les ajouter ni les supprimer.
fn calculate_sum(numbers: &Vec<i32>) -> i32 {
let mut total = 0;
for num in numbers {
total += num;
}
total
}
fn main() {
let my_numbers = vec![10, 20, 30, 40];
let sum = calculate_sum(&my_numbers); // Immutable borrow
println!("The sum is: {}", sum);
println!("Original vector: {:?}", my_numbers);
}Emprunts mutables : modifier les données
Parfois, vous devez modifier des données que vous avez empruntées. Pour cela, utilisez une référence mutable, notée &mut.
Les références mutables sont soumises à une règle essentielle : vous ne pouvez avoir qu’une seule référence mutable vers une donnée donnée à un instant donné. Cela empêche les courses aux données et garantit la sécurité.
Modifier des données avec &mut
La fonction add_suffix reçoit une référence mutable vers une String. Elle peut modifier directement la String d’origine.
fn add_suffix(text: &mut String) {
text.push_str(" (modified)");
}
fn main() {
let mut my_string = String::from("Original text");
add_suffix(&mut my_string); // Mutable borrow
println!("Modified string: {}", my_string);
}Les règles d’or de l’emprunt
Le compilateur Rust applique ces règles lors de la compilation afin de garantir la sûreté de la mémoire :
- Vous pouvez avoir une seule référence mutable vers une donnée à la fois.
- OU vous pouvez avoir autant de références immutables que vous le souhaitez à la fois.
- Vous ne pouvez pas avoir de référence mutable tant que des références immutables sont actives.
- Les références doivent toujours être valides (elles ne peuvent pas survivre aux données vers lesquelles elles pointent).
Ces règles empêchent les courses aux données et garantissent que vos programmes sont sûrs et prévisibles.
Emprunts en conflit
Ce code tente de créer simultanément une référence immutable et une référence mutable vers my_value, ce qui enfreint les règles d’emprunt de Rust. Il ne compilera PAS.
Essayez de l’exécuter pour voir l’erreur du compilateur !
fn main() {
let mut my_value = 100;
let r1 = &my_value; // Immutable reference
let r2 = &mut my_value; // Mutable reference (problem here!)
println!("r1: {}", r1);
// println!("r2: {}", r2); // This line would also cause an error if uncommented
}Vérifiez votre compréhension
Considérez l’extrait de code Rust suivant :
fn process_data(data: &mut Vec<i32>) {
data.push(4);
}
fn main() {
let mut numbers = vec![1, 2, 3];
let first_ref = &numbers[0]; // Line A
process_data(&mut numbers); // Line B
println!("First element: {}", first_ref); // Line C
}Quelle(s) ligne(s) provoqueront une erreur lors de la compilation en raison des règles d’emprunt de Rust ?
Récapitulatif : références et emprunt
Excellent travail ! Vous avez appris les notions fondamentales des références et de l’emprunt en Rust :
- Les références (
&) vous permettent d’accéder aux données sans en prendre la propriété. - L’emprunt consiste à créer une référence afin de prêter l’accès aux données.
- Les références immutables (
&) fournissent un accès en lecture seule. - Les références mutables (
&mut) fournissent un accès en lecture et en écriture. - Les règles strictes d’emprunt de Rust (une référence mutable OU plusieurs références immutables) empêchent les courses aux données et garantissent la sûreté de la mémoire lors de la compilation.
Ces concepts sont essentiels pour écrire du code Rust sûr et efficace !
Questions Fréquemment Posées
La leçon « Références et emprunt expliqués » est-elle gratuite ?
Oui — le texte complet de « Références et emprunt expliqués » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Références et emprunt expliqués » ?
Découvrez les références et l’emprunt, qui permettent à plusieurs parties de votre code d’accéder aux données sans en prendre possession, en toute sécurité. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.
Combien de temps prend la leçon « Références et emprunt expliqués » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Comprendre le modèle de propriété de Rust
- Références et emprunt expliqués
- Durées de vie pour des références sûres