Learn Rust Coding · Leçon

Ergonomie de Deref et des enveloppes

Donnez aux enveloppes un comportement natif.

Ergonomie de Deref et des enveloppes est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. 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 4 leçons au total.

Le problème d’ergonomie

Encapsuler un type dans un nouveau type améliore la sécurité, mais fait perdre en commodité : vous devez soudain écrire wrapper.0.method() partout et réimplémenter les méthodes manuellement.

Le trait Deref peut restaurer une grande partie de cette ergonomie en permettant au conteneur de se comporter comme la valeur qu’il contient.

Rôle de Deref

Deref définit ce que produit *value et alimente l’opérateur .. Lorsque vous appelez une méthode absente du conteneur, le compilateur réessaie sur la cible du déréférencement.

Cette étape automatique s’appelle la coercition par déréférencement.

use std::ops::Deref;
struct MyBox<T>(T);
impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T { &self.0 }
}

La coercition par déréférencement en action

Une fois Deref implémenté, l’appel de méthodes internes sur le conteneur fonctionne directement. Le compilateur insère .deref() pour vous jusqu’à trouver la méthode.

use std::ops::Deref;
struct Name(String);
impl Deref for Name {
    type Target = String;
    fn deref(&self) -> &String { &self.0 }
}
fn main() {
    let n = Name("rustacean".to_string());
    println!("len = {}", n.len()); // String::len via deref
}

DerefMut pour l’accès mutable

Deref ne fournit qu’un accès partagé. Pour appeler à travers le conteneur des méthodes qui nécessitent &mut self, implémentez également DerefMut, qui renvoie une référence mutable vers la valeur interne.

use std::ops::{Deref, DerefMut};
struct Stack(Vec<i32>);
impl Deref for Stack {
    type Target = Vec<i32>;
    fn deref(&self) -> &Vec<i32> { &self.0 }
}
impl DerefMut for Stack {
    fn deref_mut(&mut self) -> &mut Vec<i32> { &mut self.0 }
}

Coercition aux limites des fonctions

La coercition par déréférencement s’applique également aux arguments. Un &Name est converti en &String, qui est lui-même converti en &str ; vous pouvez donc transmettre directement le conteneur aux fonctions qui attendent une référence vers la valeur interne.

fn greet(who: &str) {
    println!("hi {}", who);
}
// greet(&name) works: &Name -> &String -> &str

Un exemple de coercition exécutable

Ce programme transmet une référence vers un conteneur là où une tranche de chaîne est attendue. Les coercitions par déréférencement en chaîne s’effectuent silencieusement au point d’appel.

use std::ops::Deref;
struct Tag(String);
impl Deref for Tag {
    type Target = String;
    fn deref(&self) -> &String { &self.0 }
}
fn shout(s: &str) { println!("{}!", s.to_uppercase()); }
fn main() {
    let t = Tag("ship".to_string());
    shout(&t);
}

N’abusez pas de Deref

Les recommandations de l’API Rust déconseillent d’implémenter Deref pour des types qui ne sont pas de véritables pointeurs intelligents. Un usage excessif rend les méthodes disponibles du conteneur imprévisibles et surprend les lecteurs.

Si le nouveau type sert à restreindre une API, un Deref systématique peut exposer précisément les méthodes que vous vouliez masquer.

AsRef comme solution ciblée

Lorsque vous avez seulement besoin d’une conversion explicite plutôt que d’une coercition automatique, implémentez AsRef. Les appelants écrivent délibérément .as_ref(), ce qui préserve une interface claire pour le conteneur.

struct Path(String);
impl AsRef<str> for Path {
    fn as_ref(&self) -> &str { &self.0 }
}

Transmettre certaines méthodes

Pour un conteneur restrictif, préférez écrire manuellement uniquement les méthodes que vous souhaitez exposer. Vous gardez ainsi le contrôle total de l’API au lieu de tout exposer par l’intermédiaire de Deref.

struct Counter(Vec<u8>);
impl Counter {
    fn len(&self) -> usize { self.0.len() }
    fn push(&mut self, b: u8) { self.0.push(b); }
}

Les pointeurs intelligents utilisent Deref

Les pointeurs intelligents standard comme Box, Rc et Arc implémentent tous Deref. C’est pourquoi vous pouvez appeler directement leurs méthodes internes. Il s’agit de l’utilisation légitime et prévue de ce trait.

use std::rc::Rc;
fn main() {
    let shared = Rc::new(String::from("data"));
    // Deref lets us call String methods directly
    println!("len = {}", shared.len());
}

Choisir votre stratégie d’ergonomie

Choisissez selon l’intention. Utilisez Deref pour de véritables conteneurs de pointeurs intelligents, AsRef pour des conversions empruntées explicites, et une transmission manuelle lorsqu’un nouveau type doit restreindre l’API de son type interne.

Un mauvais choix masque trop de choses ou en expose trop.

Vérification rapide

Déterminez quel conteneur mérite une implémentation de Deref.

Récapitulatif

Deref et la coercition par déréférencement restaurent l’ergonomie des conteneurs en permettant à l’opérateur . et aux arguments de type référence de se reporter à la valeur interne ; DerefMut ajoute l’accès mutable.

Réservez Deref aux véritables pointeurs intelligents. Pour les nouveaux types restrictifs, utilisez AsRef pour les conversions explicites ou ne transmettez que les méthodes que vous choisissez d’exposer.

Questions Fréquemment Posées

La leçon « Ergonomie de Deref et des enveloppes » est-elle gratuite ?

Oui — le texte complet de « Ergonomie de Deref et des enveloppes » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Ergonomie de Deref et des enveloppes » ?

Donnez aux enveloppes un comportement natif. 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 4 sur 4.

Combien de temps prend la leçon « Ergonomie de Deref et des enveloppes » ?

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

← Retour à Learn Rust Coding