Structures auto-référentielles en Rust : tutoriel pas à pas

Pourquoi Rust ne vous permet pas de stocker une référence sur vous-même : analyse avec des exemples

Imaginez la situation : vous écrivez un programme en Rust et vous devez créer une structure qui stocke des données, ainsi qu'une référence à ces mêmes données. Logique ? Absolument ! Mais soudain, le compilateur Rust affiche une erreur, et vous êtes perplexe. Cela vous dit quelque chose ? Cette question est l'une des plus populaires sur Stack Overflow (des milliers de vues), et aujourd'hui nous allons la décortiquer de A à Z.

Dans ce tutoriel pas à pas, nous ne comprendrons pas seulement pourquoi on ne peut pas stocker une valeur et une référence dans une même structure Rust, mais nous apprendrons aussi à contourner cette limitation de manière sécurisée. C'est parti !

Le problème : tentative naïve

Supposons que nous voulions créer une structure qui stocke une chaîne de caractères et sa première lettre (référence au premier caractère). Voici à quoi cela ressemble en code :

struct MyStruct {\n    data: String,\n    first_char: &str,  // référence à data\n}\n\nfn main() {\n    let s = String::from("Hello");\n    let first = &s[0..1];  // référence au premier caractère\n    \n    let my_struct = MyStruct {\n        data: s,\n        first_char: first,  // on essaie de sauvegarder la référence\n    };\n}\n

Le compilateur affiche une erreur qui déroute de nombreux débutants. Analysons ce qui s'est mal passé.

Pourquoi Rust interdit les structures auto-référentielles ?

La racine du problème réside dans le système de propriété (ownership) et d'emprunt (borrowing) de Rust. Lorsque vous déplacez (move) la valeur s dans le champ data, elle est physiquement copiée vers un nouvel emplacement mémoire. La référence first pointe toujours vers l'ancienne adresse, qui est désormais invalide.

En Rust, chaque référence doit être valide pendant toute sa durée de vie. Les structures auto-référentielles Rust violent cette règle, car la référence et la valeur vivent dans le même objet, et lors du déplacement de la structure, la référence devient pendante (dangling reference).

Que se passe-t-il sous le capot ?

Lorsque vous écrivez ce code :

let s = String::from("Hello");\nlet first = &s[0..1];\nlet my_struct = MyStruct { data: s, first_char: first };\n

Voici ce qui se produit :

\n
1. s possède la chaîne "Hello" dans le tas.
\n
2. first est une référence vers une partie de cette chaîne.
\n
3. Lors de la création de la structure, data: s transfère la propriété de la chaîne à la structure. La chaîne peut être déplacée en mémoire.
\n
4. La référence first pointe toujours vers l'ancienne adresse — c'est une référence pendante. Rust ne peut pas le permettre.
\n

Le Borrow checker de Rust détecte cette insécurité potentielle et bloque le code à la compilation. Ce n'est pas un bug, mais une fonctionnalité qui évite de nombreux problèmes à l'exécution.

Scénarios réels où les structures auto-référentielles sont nécessaires

Malgré l'interdiction, ces structures peuvent être utiles. Voici des cas typiques :

\n
• Analyseurs syntaxiques et AST : lorsque les nœuds de l'arbre se référencent mutuellement.
\n
• Moteurs de jeux : entités contenant des références à leurs composants.
\n
• Protocoles réseau : tampons avec des pointeurs internes.
\n
• Systèmes de plugins : lorsqu'un objet contient une référence à sa configuration.
\n

Bonne nouvelle : il existe des moyens sécurisés de contourner cette limitation !

Solution 1 : Utiliser des index au lieu de références (la méthode la plus simple)

La méthode la plus simple et la plus sûre est de stocker non pas une référence, mais un index ou une clé. Au lieu de &str, stockez un usize (la position du premier caractère).

struct MyStruct {\n    data: String,\n    first_char_index: usize,  // on stocke la position, pas la référence\n}\n\nimpl MyStruct {\n    fn first_char(&self) -> &