Pointeurs intelligents Box, Rc et Arc
Comprenez comment `Box` pour l’allocation sur le tas, `Rc` pour la propriété partagée et `Arc` pour la propriété partagée sûre entre threads gèrent les données.
Pointeurs intelligents Box, Rc et Arc est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 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 pointeurs intelligents ?
Le système de propriété de Rust est excellent pour garantir la sûreté de la mémoire, mais vous avez parfois besoin de davantage de flexibilité. C’est là qu’interviennent les pointeurs intelligents !
Les pointeurs intelligents sont des structures de données qui se comportent comme des pointeurs, tout en possédant des métadonnées et des capacités supplémentaires. Ils gèrent automatiquement la mémoire, la propriété et d’autres ressources.
Box : stocker des données sur le tas
Le pointeur intelligent le plus simple est Box<T>. Il vous permet de stocker des données sur le tas plutôt que sur la pile.
- Pile : données rapides et de taille fixe.
- Tas : données plus lentes, de taille flexible et allouées à l’exécution.
Lorsque vous placez une valeur dans une Box, la Box elle-même se trouve sur la pile, mais les données vers lesquelles elle pointe vivent sur le tas.
Utiliser Box pour allouer sur le tas
Voyons comment Box déplace des données sur le tas. Cela est utile pour les données volumineuses ou lorsque vous ne connaissez pas leur taille au moment de la compilation.
Exécutez ce code pour observer une valeur placée dans une boîte.
fn main() {
let x = 5; // x is on the stack
let boxed_x = Box::new(x); // x's value is moved to the heap, boxed_x is on stack
println!("Value on stack: {}", x);
println!("Value in Box (on heap): {}", *boxed_x); // Dereference to get value
}Quand Box est utile
Vous pouvez utiliser Box<T> dans les situations suivantes :
- Lorsque vous avez un type dont la taille ne peut pas être connue au moment de la compilation et que vous devez le stocker dans un emplacement de taille connue et fixe.
- Lorsque vous avez une grande quantité de données et que vous voulez transférer leur propriété sans copier les données elles-mêmes.
- Lorsque vous voulez posséder un objet de trait (par exemple,
Box<dyn Trait>).
Rc : plusieurs propriétaires (un seul fil)
Les règles de propriété de Rust signifient qu’une valeur n’a généralement qu’un seul propriétaire. Mais que faire si plusieurs parties de votre programme doivent « posséder » les mêmes données ?
Rc<T>, ou comptage des références, permet à plusieurs propriétaires de partager des données dans un contexte à un seul fil. Il suit le nombre de références qui pointent vers les données.
Lorsque le compteur atteint zéro, les données sont libérées.
Partager des données avec Rc
Rc::clone() incrémente le compteur de références. Il ne s’agit pas d’une copie profonde : cela crée simplement un autre pointeur vers les mêmes données.
Remarquez que les données sont partagées et que leur valeur est accessible depuis différents « propriétaires ».
use std::rc::Rc;
fn main() {
let value = Rc::new(String::from("Shared String"));
println!("Count after creation: {}", Rc::strong_count(&value));
let value_clone_a = Rc::clone(&value); // Increment count
println!("Count after clone A: {}", Rc::strong_count(&value));
{
let value_clone_b = Rc::clone(&value); // Increment count
println!("Count after clone B: {}", Rc::strong_count(&value));
println!("Data from A: {}", value_clone_a);
println!("Data from B: {}", value_clone_b);
} // value_clone_b goes out of scope, count decreases
println!("Count after B goes out of scope: {}", Rc::strong_count(&value));
}Arc : propriété partagée (plusieurs fils)
Rc<T> fonctionne bien dans les applications à un seul fil. Cependant, si vous devez partager des données entre plusieurs fils, Rc<T> n’est pas sûr.
Arc<T>, ou comptage atomique des références, est la version de Rc<T> sûre pour les fils. Il utilise des opérations atomiques pour mettre à jour le compteur de références, ce qui garantit la sûreté entre les fils.
Arc entraîne une légère surcharge de performances par rapport à Rc en raison des opérations atomiques.
Partager des données entre des fils avec Arc
Cet exemple montre comment Arc permet à plusieurs fils d’accéder aux mêmes données partagées et de les lire en toute sûreté. Chaque fil reçoit son propre clone de `Arc`.
Le fil principal attend que tous les fils créés aient terminé.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let mut handles = vec![];
for i in 0..3 {
let data_clone = Arc::clone(&data); // Clone Arc for each thread
let handle = thread::spawn(move || {
println!("Thread {} has data: {:?}", i, *data_clone);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("All threads finished.");
}Box, Rc ou Arc ?
Le choix du pointeur intelligent adapté dépend de vos besoins :
Box<T>: lorsque vous devez placer des données sur le tas, généralement pour une propriété unique ou pour gérer des types récursifs.Rc<T>: lorsque vous avez besoin de plusieurs propriétaires pour des données dans un contexte à un seul fil.Arc<T>: lorsque vous avez besoin de plusieurs propriétaires pour des données dans un contexte à plusieurs fils (concurrent).
Préférez toujours Box ou Rc si vous n’avez pas besoin de la sûreté entre les fils, car Arc a un coût en performances.
Vérification des pointeurs intelligents
Vous devez stocker un fichier image volumineux sur le tas, et une seule partie de votre programme en sera propriétaire et le gérera. Quel pointeur intelligent devez-vous utiliser ?
Récapitulatif : pointeurs intelligents
Dans cette leçon, vous avez découvert trois pointeurs intelligents fondamentaux de Rust :
Box<T>: pour allouer des données sur le tas avec un propriétaire unique.Rc<T>: pour permettre à plusieurs propriétaires de partager des données dans un environnement à un seul fil.Arc<T>: pour permettre à plusieurs propriétaires sûrs entre les fils de partager des données dans un environnement à plusieurs fils.
Ces pointeurs intelligents vous donnent davantage de contrôle sur la gestion de la mémoire tout en vous permettant de profiter des garanties de sûreté de Rust.
Questions Fréquemment Posées
La leçon « Pointeurs intelligents Box, Rc et Arc » est-elle gratuite ?
Oui — le texte complet de « Pointeurs intelligents Box, Rc et Arc » 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 « Pointeurs intelligents Box, Rc et Arc » ?
Comprenez comment `Box` pour l’allocation sur le tas, `Rc` pour la propriété partagée et `Arc` pour la propriété partagée sûre entre threads gèrent les données. 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 1 sur 3.
Combien de temps prend la leçon « Pointeurs intelligents Box, Rc et Arc » ?
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
- Pointeurs intelligents Box, Rc et Arc
- Mutabilité intérieure : RefCell, Cell
- Concurrence sans crainte avec les threads