La même possession unique — mais la donnée vit ailleurs, sur le tas.The same single ownership — but the data lives elsewhere, on the heap.
Le Vol 1 a posé la possession comme un arbre : un propriétaire par donnée, libérée quand son propriétaire disparaît. Ce volume montre les échappatoires quand l'arbre strict ne suffit pas — et leur prix. Box<T> est la première, la plus simple, et celle qui ne quitte presque pas l'arbre. Une Box ne change rien à la règle « un seul propriétaire » : elle déplace seulement la donnée de la pile vers le tas, et garde sur la pile un pointeur vers elle. Pourquoi le voudrait-on ? Parce que certaines choses n'ont pas de taille connue à la compilation, ou n'en ont pas du tout sur la pile : un type récursif, un trait object, une valeur énorme qu'on ne veut pas copier en bloc. Box leur donne une adresse fixe sur le tas, et une taille fixe — celle d'un pointeur — sur la pile.Vol 1 set ownership as a tree: one owner per piece of data, freed when its owner goes away. This volume shows the escapes when the strict tree falls short — and their price. Box<T> is the first, the simplest, and the one that barely leaves the tree at all. A Box changes nothing about the 'single owner' rule: it merely moves the data from the stack to the heap, and keeps on the stack a pointer to it. Why would you want that? Because some things have no compile-time size, or none on the stack at all: a recursive type, a trait object, a huge value you don't want to copy wholesale. Box gives them a fixed address on the heap, and a fixed size — that of a pointer — on the stack.
// Box<T> : la valeur vit sur le TAS, un pointeur la tient sur la PILE let sur_la_pile: i32 = 42; // 4 octets, directement sur la pile let sur_le_tas: Box<i32> = Box::new(42); // un pointeur sur la pile → 42 sur le tas println!("{}", *sur_le_tas); // * déréférence : on lit la valeur pointée // la possession reste UNIQUE et l'arbre intact : un seul propriétaire (la Box), // libération automatique à la fin de portée. on a juste déporté la donnée.
La pile est rapide, automatique, à taille fixe connue à la compilation : c'est là que vivent par défaut tes variables. Le tas est une zone plus libre où l'on alloue à la demande, pour ce dont la taille n'est pas connue à l'avance ou doit survivre à un cadre de pile. Box::new(v) alloue sur le tas, y déplace v, et te rend un pointeur. Quand la Box sort de portée, sa donnée sur le tas est libérée — automatiquement, sans ramasse-miettes, par le même mécanisme de possession que tout le reste.The stack is fast, automatic, of fixed compile-time size: that's where your variables live by default. The heap is a freer area where you allocate on demand, for things whose size isn't known ahead or must outlive a stack frame. Box::new(v) allocates on the heap, moves v there, and hands you a pointer. When the Box goes out of scope, its heap data is freed — automatically, no garbage collector, by the same ownership mechanism as everything else.
« Ai-je une raison précise de mettre cette valeur sur le tas ? » Trois bonnes raisons : un type récursif (qui se contient lui-même), un type non dimensionné (un dyn Trait, vu au Vol 5), ou une valeur si grosse que la déplacer sur la pile coûte cher. Hors de ces cas, la pile suffit — et Box n'ajouterait qu'une allocation inutile.'Do I have a precise reason to put this value on the heap?' Three good ones: a recursive type (one that contains itself), an unsized type (a dyn Trait, from Vol 5), or a value so large that moving it on the stack is costly. Outside these, the stack suffices — and Box would only add a needless allocation.
Box est le premier des « smart pointers » : des types qui se comportent comme un pointeur mais gèrent une ressource. Box ne fait qu'une chose — posséder une donnée sur le tas et la libérer à la fin. Pas de comptage, pas de partage, pas de vérification à l'exécution. C'est pour ça qu'il ne coûte presque rien et qu'il ne quitte pas vraiment l'arbre de possession : un seul propriétaire, comme avant. Les numéros suivants — Rc, RefCell — ajouteront le partage et la mutabilité intérieure, avec leur prix.Box is the first of the 'smart pointers': types that behave like a pointer but manage a resource. Box does just one thing — own a piece of data on the heap and free it at the end. No counting, no sharing, no runtime check. That's why it costs almost nothing and doesn't really leave the ownership tree: a single owner, as before. The next issues — Rc, RefCell — will add sharing and interior mutability, with their price.