Durées de vie en Rust

Le mécanisme de durée de vie de Rust est un mécanisme de gestion des ressources aussi important que le mécanisme de propriété.

La principale raison de l'introduction de ce concept est de traiter les problèmes de gestion des ressources dans les systèmes de types complexes.

Les références sont un mécanisme essentiel lorsqu'on traite des types complexes ; après tout, les données de types complexes ne peuvent pas être facilement copiées et calculées par le processeur.

Mais les références conduisent souvent à des problèmes de gestion des ressources extrêmement complexes. Tout d'abord, comprenons les références pendantes :

Exemple

{
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {}", r);
}

Ce code ne passera pas le compilateur Rust car la valeur référencée par r a déjà été libérée avant d'être utilisée.

Dans le diagramme ci-dessus, la plage verte 'a représente la durée de vie de r, et la plage bleue 'b représente la durée de vie de x. Évidemment, 'b est bien plus courte que 'a ; une référence doit être dans la durée de vie de la valeur pour être valide.

Nous avons toujours utilisé String plutôt que &str dans les structs. Utilisons un exemple pour expliquer pourquoi :

Exemple

fn longer(s1: &str, s2: &str) -> &str {
    if s2.len() > s1.len() {
        s2
    } else {
        s1
    }
}

La fonction longer prend deux tranches de chaîne, s1 et s2, et renvoie la référence de la plus longue. Cependant, ce code ne compilera pas car la référence renvoyée peut être une référence pendante :

Exemple

fn main() {
    let r;
    {
        let s1 = "rust";
        let s2 = "ecmascript";
        r = longer(s1, s2);
    }
    println!("{} est plus long", r);
}

Dans ce programme, bien qu'une comparaison ait été faite, au moment où r est utilisé, les valeurs sources s1 et s2 sont déjà devenues invalides. Bien sûr, nous pourrions déplacer l'utilisation de r dans la durée de vie de s1 et s2 pour éviter cette erreur, mais pour la fonction, elle ne peut pas savoir ce qui se passe à l'extérieur d'elle-même. Afin de garantir que la valeur qu'elle transmet est valide, elle doit suivre le principe de propriété pour éliminer tous les dangers, donc la fonction longer ne peut pas compiler.

Annotation de durée de vie

Une annotation de durée de vie est une façon de décrire la durée de vie des références.

Bien que cela ne puisse pas modifier la durée de vie des références, cela peut déclarer que les durées de vie de deux références sont cohérentes aux endroits appropriés.

Une annotation de durée de vie commence par une apostrophe et est suivie d'un mot en minuscules :

&i32        // 常规引用
&'a i32     // 含有生命周期注释的引用
&'a mut i32 // 可变型含有生命周期注释的引用

Refactorisons la fonction longer en utilisant des annotations de durée de vie :

Exemple

fn longer<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s2.len() > s1.len() {
        s2
    } else {
        s1
    }
}

Nous devons utiliser des déclarations génériques pour spécifier les noms des durées de vie ; alors la durée de vie de la valeur de retour de la fonction sera cohérente avec les durées de vie des deux paramètres, donc lors de l'appel, nous pouvons écrire :

Exemple

fn main() {
    let r;
    {
        let s1 = "rust";
        let s2 = "ecmascript";
        r = longer(s1, s2);
        println!("{} est plus long", r);
    }
}

La sortie combinée des deux programmes ci-dessus :

ecmascript is longer

Remarque :N'oubliez pas le principe d'inférence automatique de type.

Utilisation de références de tranches de chaîne dans les structures

C'est la question laissée précédemment ; voici la réponse :

Exemple

fn main() {
    struct Str<'a> {
        content: &'
a str
    }
    let s = Str {
        content: "string_slice"
    };
    println!("s.content = {}", s.content);
}

Sortie :

s.content = string_slice

S'il existe une définition de méthode pour la structure Str :

Exemple

impl<'a> Str<'a> {
    fn get_content(&self) -> &str {
        self.content
    }
}

La valeur de retour ici n'a pas d'annotation de durée de vie, mais en ajouter une ne fait pas de mal. C'est un problème historique : les premières versions de Rust ne prenaient pas en charge l'inférence automatique des durées de vie, et toutes les durées de vie devaient être déclarées strictement, mais les versions stables courantes de Rust prennent déjà en charge cette fonctionnalité.

Durée de vie statique

Il existe une annotation de durée de vie spéciale : 'static. Le type de données exact représenté par toutes les constantes de chaîne entre guillemets doubles est &'static str ; la durée de vie désignée par 'static dure du début de l'exécution du programme jusqu'à la fin de l'exécution du programme.

Génériques, traits et durées de vie travaillant ensemble

Exemple

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
    where T: Display
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

Ce programme provient de la Bible Rust (Rust Book). C'est un programme qui utilise en même temps les génériques, les traits et les mécanismes de durée de vie. Il n'est pas obligatoire ; vous pouvez l'essayer, après tout, vous en aurez besoin tôt ou tard !

Autres extensions