{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Quel est le principal cas d'usage de Box en Rust ?","acceptedAnswer":{"@type":"Answer","text":"Box permet d'allouer des donnees sur le heap plutot que sur la stack. C'est utile pour les types de taille inconnue a la compilation (types recursifs), pour transferer la propriete de grandes donnees sans copie, ou pour creer des trait objects. Le pointeur Box lui-meme a une taille fixe sur la stack."}},{"@type":"Question","name":"Comment definir un type recursif comme une liste chainee en Rust ?","acceptedAnswer":{"@type":"Answer","text":"Un type recursif direct comme enum List { Cons(i32, List), Nil } ne compile pas car le compilateur ne peut pas determiner la taille. En utilisant Box, on cree une indirection avec une taille fixe (pointeur), permettant au compilateur de calculer la taille du type."}},{"@type":"Question","name":"Quelle est la difference principale entre Rc et Arc ?","acceptedAnswer":{"@type":"Answer","text":"Rc (Reference Counted) utilise un compteur de references non-atomique, ce qui le rend plus performant mais limite a un seul thread. Arc (Atomically Reference Counted) utilise des operations atomiques pour le compteur, permettant le partage entre threads mais avec un leger overhead de performance."}},{"@type":"Question","name":"Que permet le trait Deref en Rust ?","acceptedAnswer":{"@type":"Answer","text":"Le trait Deref permet de personnaliser le comportement de l'operateur de dereferencement (*). Il active egalement le deref coercion, permettant au compilateur de convertir automatiquement une reference vers un type implementant Deref en une reference vers le type cible, comme &Box vers &T."}},{"@type":"Question","name":"Qu'est-ce que la mutabilite interieure (interior mutability) en Rust ?","acceptedAnswer":{"@type":"Answer","text":"La mutabilite interieure est un pattern de conception qui permet de modifier des donnees meme lorsqu'il existe des references immuables vers ces donnees. Elle utilise des types comme RefCell ou Cell qui deplacent les verifications d'emprunt a l'execution plutot qu'a la compilation."}},{"@type":"Question","name":"Que se passe-t-il si on tente d'emprunter mutablement deux fois un RefCell simultanement ?","acceptedAnswer":{"@type":"Answer","text":"RefCell applique les regles d'emprunt a l'execution. Si on appelle borrow_mut() deux fois sans que le premier emprunt soit libere, le programme panic. C'est le prix de la mutabilite interieure : les erreurs d'emprunt deviennent des erreurs a l'execution plutot qu'a la compilation."}},{"@type":"Question","name":"Comment creer une nouvelle instance de Rc qui partage la meme donnee qu'une instance existante ?","acceptedAnswer":{"@type":"Answer","text":"La methode Rc::clone() incremente le compteur de references et retourne un nouveau Rc pointant vers la meme donnee. Contrairement a un clone profond, cette operation est peu couteuse car elle ne copie que le pointeur et incremente un compteur entier."}},{"@type":"Question","name":"Quand le trait Drop est-il appele pour une valeur en Rust ?","acceptedAnswer":{"@type":"Answer","text":"Le trait Drop est automatiquement appele par le compilateur quand une valeur sort de sa portee. Cela permet de liberer des ressources comme la memoire heap, les fichiers ouverts ou les connexions reseau. L'ordre de drop suit l'ordre inverse de creation des variables."}},{"@type":"Question","name":"Comment forcer la liberation anticipee d'une valeur avant la fin de sa portee ?","acceptedAnswer":{"@type":"Answer","text":"La fonction std::mem::drop() permet de forcer la liberation d'une valeur avant la fin de sa portee. C'est utile pour liberer des ressources comme des verrous plus tot que prevu. On ne peut pas appeler value.drop() directement car le compilateur l'appelle deja automatiquement."}},{"@type":"Question","name":"Quel est le probleme des cycles de references avec Rc ?","acceptedAnswer":{"@type":"Answer","text":"Les cycles de references avec Rc creent des fuites de memoire. Si A reference B et B reference A via Rc, les compteurs ne tombent jamais a zero meme quand plus aucune variable externe ne reference ces valeurs. La memoire n'est jamais liberee car chaque element maintient l'autre en vie."}},{"@type":"Question","name":"Comment eviter les cycles de references avec Rc ?","acceptedAnswer":{"@type":"Answer","text":"Weak est une version non-proprietaire de Rc qui n'incremente pas le strong count. Quand toutes les references Rc sont liberees, la valeur est detruite meme s'il reste des Weak. Pour acceder a la valeur, il faut appeler upgrade() qui retourne Option>."}},{"@type":"Question","name":"Quelle est la difference entre Cell et RefCell ?","acceptedAnswer":{"@type":"Answer","text":"Cell fonctionne par copie : on peut get() et set() la valeur entiere mais pas obtenir de reference. RefCell fonctionne par emprunt : on peut obtenir des references (&T via borrow(), &mut T via borrow_mut()). Cell est plus leger mais limite aux types Copy."}},{"@type":"Question","name":"Comment combiner Rc et RefCell pour avoir un partage avec mutabilite ?","acceptedAnswer":{"@type":"Answer","text":"Le pattern Rc> permet d'avoir plusieurs proprietaires (Rc) d'une donnee mutable (RefCell). Chaque proprietaire peut modifier la valeur via borrow_mut(). C'est un pattern courant pour les graphes ou arbres avec references parentes/enfants mutuelles."}},{"@type":"Question","name":"Que retourne la methode Weak::upgrade() ?","acceptedAnswer":{"@type":"Answer","text":"Weak::upgrade() retourne Option>. Elle retourne Some(Rc) si la valeur existe encore (strong count > 0), ou None si la valeur a ete liberee. C'est necessaire car Weak ne garantit pas que la valeur existe toujours."}},{"@type":"Question","name":"Pourquoi Rc n'implemente pas le trait Send ?","acceptedAnswer":{"@type":"Answer","text":"Rc utilise un compteur de references non-atomique qui n'est pas thread-safe. Si deux threads modifiaient le compteur simultanement, cela causerait des data races. Arc utilise des operations atomiques pour le compteur et implemente Send et Sync."}},{"@type":"Question","name":"Qu'est-ce que le deref coercion en Rust ?","acceptedAnswer":{"@type":"Answer","text":"Le deref coercion est une conversion automatique effectuee par le compilateur sur les types implementant Deref. Par exemple, &String vers &str, ou &Box vers &T. Cela permet d'utiliser &String partout ou &str est attendu sans conversion explicite."}},{"@type":"Question","name":"Quelle est la signature du trait Deref ?","acceptedAnswer":{"@type":"Answer","text":"Le trait Deref definit un type associe Target et une methode deref() qui retourne &Self::Target. Cela permet a l'operateur * de convertir &T en &Target. Le trait DerefMut est similaire mais retourne &mut Self::Target pour les dereferencements mutables."}},{"@type":"Question","name":"Comment obtenir le nombre de references fortes d'un Rc ?","acceptedAnswer":{"@type":"Answer","text":"Rc::strong_count(&rc) retourne le nombre de references fortes (Rc) pointant vers la valeur. Rc::weak_count(&rc) retourne le nombre de references faibles (Weak). Ces fonctions sont utiles pour le debugging et la comprehension du comportement du programme."}},{"@type":"Question","name":"Dans quel cas utiliser Arc> plutot que Rc> ?","acceptedAnswer":{"@type":"Answer","text":"Arc> est necessaire pour le partage mutable entre threads. Arc fournit le comptage atomique thread-safe, et Mutex fournit l'exclusion mutuelle pour la mutabilite. Rc> n'est pas thread-safe et ne peut etre utilise que dans un contexte mono-thread."}},{"@type":"Question","name":"Que se passe-t-il si on implemente Drop pour un type qui implemente aussi Copy ?","acceptedAnswer":{"@type":"Answer","text":"C'est impossible en Rust. Les types Copy sont copies bit a bit et il serait ambigu de savoir quand appeler drop(). Si drop() etait appele sur chaque copie, cela causerait des double-free. Le compilateur refuse d'implementer les deux traits sur le meme type."}},{"@type":"Question","name":"Comment creer un Weak a partir d'un Rc ?","acceptedAnswer":{"@type":"Answer","text":"La methode Rc::downgrade(&rc) cree un Weak a partir d'un Rc. Cette operation incremente le weak count mais pas le strong count. Le Weak resultant peut etre upgrade() plus tard pour tenter d'obtenir un Rc, retournant None si la valeur a ete liberee."}},{"@type":"Question","name":"Quelle methode utiliser pour verifier si un emprunt RefCell est possible sans panic ?","acceptedAnswer":{"@type":"Answer","text":"Les methodes try_borrow() et try_borrow_mut() retournent Result au lieu de panic. Elles retournent Ok(Ref) ou Ok(RefMut) si l'emprunt est valide, ou Err(BorrowError) si l'emprunt violerait les regles. C'est utile quand un panic n'est pas acceptable."}}]}