0Pricing
Learn Rust Coding · Leçon

Durées de vie pour des références sûres

Approfondissez les durées de vie, le mécanisme de Rust qui garantit que les références sont toujours valides et empêche les pointeurs pendants au moment de la compilation.

Durées de vie pour des références sûres est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 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.

Pourquoi lifetime est important

Les règles de propriété et d’emprunt de Rust empêchent de nombreuses erreurs de mémoire courantes. Mais il existe un niveau de sécurité supplémentaire : les lifetimes.

Les lifetimes garantissent que les références de votre code pointent toujours vers des données valides. Elles résolvent le problème des références pendantes, lorsqu’une référence peut pointer vers une zone mémoire déjà désallouée.

Le risque des pointeurs pendants

Imaginez qu’une fonction crée des données, renvoie une référence vers celles-ci, puis que les données soient détruites à la fin de la fonction. La référence renvoyée pointerait alors vers une zone mémoire invalide.

Rust utilise les lifetimes pour empêcher cela lors de la compilation. Il vérifie que toute référence utilisée restera valide aussi longtemps que nécessaire, garantissant ainsi la sûreté de la mémoire.

Rust déduit les lifetimes

Vous n’avez pas toujours besoin d’écrire explicitement les annotations de lifetime. Rust dispose d’un ensemble de règles d’omission des lifetimes qui permettent au compilateur de les déduire dans les cas courants.

Par exemple, dans une fonction avec une seule référence en entrée, son lifetime est souvent automatiquement attribué à la référence en sortie. Votre code reste ainsi plus clair !

Quand ajouter une annotation

Lorsque Rust ne peut pas déduire les lifetimes, vous devez les annoter explicitement. Cela indique au compilateur comment les lifetimes des différentes références sont liés entre eux.

La syntaxe d’une annotation de lifetime est une apostrophe suivie d’une lettre minuscule, comme 'a. Il s’agit d’un paramètre générique pour les lifetimes, et non d’une durée précise.

Paramètres de lifetime des fonctions

Lorsqu’une fonction reçoit plusieurs références et en renvoie une, Rust doit savoir quel lifetime d’une référence d’entrée la référence de sortie doit avoir. Cela garantit que la référence renvoyée est toujours valide.

La syntaxe <'a> déclare un paramètre de lifetime générique. Regardons un exemple :

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

fn main() {
  let string1 = String::from("abcd");
  let string2 = "xyz";
  let result = longest(string1.as_str(), string2);
  println!("The longest string is: {}", result);
}

Le lifetime 'static

Le 'static lifetime est un cas particulier. Il indique qu'une référence peut rester valide pendant toute la durée d'exécution du programme.

Les littéraux de chaîne (par exemple, "hello world") ont le 'static lifetime, car ils sont stockés directement dans le binaire du programme et sont disponibles pendant toute son exécution.

fn main() {
  // 'static lifetime for a string literal
  let s: &'static str = "I live for the entire program!";
  println!("{}", s);

  // This is also implicitly 'static
  let another_s = "Hello from static land!";
  println!("{}", another_s);
}

Structures contenant des références

Si une structure contient une référence, vous devez ajouter une annotation de lifetime à sa définition. Cela garantit qu'aucune instance de la structure ne survivra aux données vers lesquelles ses références pointent.

Le paramètre de lifetime de la structure indique à Rust que toutes les références qu'elle contient doivent avoir au moins cette lifetime.

struct ImportantExcerpt<'a> {
  part: &'a str,
}

fn main() {
  let novel = String::from("Call me Ishmael. Some years ago...");
  let first_sentence = novel.split('.').next().expect("Could not find a '.'");
  let i = ImportantExcerpt {
    part: first_sentence,
  };
  println!("Excerpt part: {}", i.part);
}

Lifetimes et génériques

Les lifetimes sont une forme de génériques ! Vous pouvez les combiner avec des génériques de type pour créer des structures de données ou des fonctions flexibles et sûres.

Par exemple, une structure peut contenir des références vers des types génériques, toutes contraintes par un seul paramètre de lifetime, ce qui garantit la validité de relations complexes entre les données.

Comprendre les erreurs du compilateur

Lorsque vous rencontrez des erreurs de lifetime pour la première fois, elles peuvent sembler intimidantes. L'erreur la plus courante est « borrow might not live long enough ».

Cela signifie généralement que vous essayez d'utiliser une référence après la suppression des données vers lesquelles elle pointe, ou que Rust ne peut pas prouver qu'elle est valide. Comprendre ces messages vous aide à ajuster vos annotations de lifetime.

Vérification rapide : lifetimes

Laquelle des propositions suivantes décrit le mieux le problème fondamental que les annotations explicites de lifetime de Rust cherchent à résoudre ?

Lifetimes : sécurité à la compilation

Vous avez appris que les lifetimes sont essentielles aux garanties de sécurité mémoire de Rust. Elles empêchent les références pendantes en garantissant que toutes les références restent valides pendant toute leur utilisation.

  • Rust déduit souvent les lifetimes grâce aux règles d'omission.
  • Vous utilisez des annotations explicites comme 'a lorsque l'inférence est impossible.
  • Les lifetimes sont essentielles pour les fonctions qui renvoient des références et pour les structures contenant des références.
  • La lifetime spéciale 'static' dure pendant toute l'exécution du programme.

Maîtriser les lifetimes est essentiel pour écrire du code Rust robuste !

Questions Fréquemment Posées

La leçon « Durées de vie pour des références sûres » est-elle gratuite ?

Oui — le texte complet de « Durées de vie pour des références sûres » 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 « Durées de vie pour des références sûres » ?

Approfondissez les durées de vie, le mécanisme de Rust qui garantit que les références sont toujours valides et empêche les pointeurs pendants au moment de la compilation. 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 3 sur 3.

Combien de temps prend la leçon « Durées de vie pour des références sûres » ?

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

  1. Comprendre le modèle de propriété de Rust
  2. Références et emprunt expliqués
  3. Durées de vie pour des références sûres
← Retour à Learn Rust Coding