Box<T>, ou la possession unique déportée Box<T>, or single ownership relocated

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.

Un type qui se contient lui-même a une taille infinie — sauf derrière un pointeur.A type that contains itself has infinite size — except behind a pointer.

Voici le cas d'école qui rend Box indispensable. Pour poser une valeur sur la pile, le compilateur doit connaître sa taille exacte. Or un type récursif — une liste chaînée, un arbre — se contient lui-même : pour connaître la taille d'un maillon, il faudrait connaître la taille du maillon suivant, qui contient le suivant… à l'infini. Le compilateur refuse, avec l'erreur « infinite size ». La solution n'est pas de renoncer à la récursion, mais d'y insérer une indirection : un Box. Un pointeur a une taille fixe — un mot machine — quel que soit ce qu'il pointe. Remplacer « contient une Liste » par « contient un pointeur vers une Liste » rend la taille finie, et la récursion possible. Le tas devient le lieu où la structure peut grandir sans que la pile ait à la mesurer.Here's the textbook case that makes Box indispensable. To place a value on the stack, the compiler must know its exact size. But a recursive type — a linked list, a tree — contains itself: to know a node's size, you'd need the next node's size, which contains the next… infinitely. The compiler refuses, with the 'infinite size' error. The solution isn't to give up recursion, but to insert an indirection into it: a Box. A pointer has a fixed size — one machine word — whatever it points to. Replacing 'contains a Liste' with 'contains a pointer to a Liste' makes the size finite, and recursion possible. The heap becomes the place where the structure can grow without the stack having to measure it.

// Une liste chaînée « naïve » : chaque maillon contient le suivant… directement
enum Liste {
    Cons(i32, Liste),   // un i32, PUIS une autre Liste — par valeur
    Nil,
}

// error[E0072]: recursive type `Liste` has infinite size
//   pour calculer la taille de Liste, il faut la taille de Liste, qui contient
//   une Liste, qui contient une Liste… la récursion ne s'arrête jamais.

Déplacer une Box, c'est déplacer un pointeur — pas la donnée pointée.Moving a Box means moving a pointer — not the data it points to.

Une Box obéit à toutes les règles du Vol 1 — elle a un propriétaire, se déplace par move, se libère à la fin de portée — mais avec une nuance qui la rend précieuse. Comme la donnée vit sur le tas et que la Box n'en détient qu'un pointeur, déplacer la Box ne copie que le pointeur : quelques octets, quelle que soit la taille de la valeur. Déplacer une structure d'un mégaoctet posée sur la pile recopierait un mégaoctet ; la même valeur dans une Box se déplace en copiant huit octets. L'accès se fait par déréférencement, souvent automatique grâce au trait Deref, si bien qu'une Box s'utilise presque comme la valeur elle-même. Et quand elle meurt, son implémentation de Drop rend la mémoire du tas — automatiquement, sans ramasse-miettes, exactement comme pour une valeur de pile.A Box obeys all of Vol 1's rules — it has an owner, moves by move, frees at end of scope — but with a nuance that makes it precious. Since the data lives on the heap and the Box holds only a pointer to it, moving the Box copies only the pointer: a few bytes, whatever the value's size. Moving a one-megabyte struct sitting on the stack would recopy a megabyte; the same value in a Box moves by copying eight bytes. Access happens through dereferencing, often automatic thanks to the Deref trait, so a Box is used almost like the value itself. And when it dies, its Drop implementation returns the heap memory — automatically, no garbage collector, exactly as for a stack value.

let a = Box::new([0u8; 1_000_000]);   // 1 Mo sur le TAS, un pointeur sur la pile
let b = a;                            // move : on copie le POINTEUR (8 octets),
                                      // PAS le mégaoctet. a est invalidé (Vol 1).
// déplacer une Box est toujours bon marché, quelle que soit la taille pointée.

let boite = Box::new(Point { x: 1, y: 2 });

let px = boite.x;        // Deref automatique : boite.x ≡ (*boite).x
afficher(&*boite);       // *boite emprunte la valeur sur le tas

// à la fin de portée, Drop de Box libère le tas — automatiquement :
//   { let b = Box::new(gros_buffer); }   // ← ici, le tas est rendu, sans GC

Le Box par réflexe : une allocation et une indirection pour rien.The reflexive Box: an allocation and an indirection for nothing.

Qui vient d'un langage où « tout est sur le tas » a le réflexe d'emballer par défaut. En Rust, c'est l'inverse : la pile est le lieu naturel, et Box l'exception qu'on justifie. Mettre dans une Box une valeur de petite taille connue — un entier, un booléen — coûte plus cher que la valeur elle-même : on paie une allocation tas et une indirection à chaque accès, pour déplacer deux octets. Pire, on emballe parfois des types qui possèdent déjà leur tas : un String, un Vec gèrent leur propre tampon ; les mettre dans une Box ajoute une seconde indirection inutile. Et un Vec<Box<T>> sacrifie la contiguïté qui fait la vitesse du Vec, échangeant un bloc compact contre une myriade d'allocations éparpillées. Le Box gratuit ne résout aucun problème : il en crée un de performance.Anyone from a language where 'everything is on the heap' reflexively boxes by default. In Rust it's the opposite: the stack is the natural place, and Box the exception you justify. Putting a small, known-size value — an integer, a boolean — in a Box costs more than the value itself: you pay a heap allocation and an indirection on each access, to move two bytes. Worse, you sometimes box types that already own their heap: a String, a Vec manage their own buffer; putting them in a Box adds a needless second indirection. And a Vec<Box<T>> sacrifices the contiguity that makes a Vec fast, trading a compact block for a scattering of allocations. The gratuitous Box solves no problem: it creates a performance one.

// Box par habitude, sur des valeurs qui n'en ont aucun besoin
struct Config {
    port: Box<u16>,          // ✕ un u16 fait 2 octets : le Box coûte plus que la valeur
    nom: Box<String>,        // ✕ String possède DÉJÀ son tampon sur le tas — double indirection
}

let nombres: Vec<Box<i32>> = vec![Box::new(1), Box::new(2), Box::new(3)];
// ✕ un Vec<i32> range déjà ses éléments de façon contiguë sur le tas.
// chaque Box ajoute une allocation séparée et un saut de pointeur, pour RIEN.

Box<u16> stocke sur le tas une valeur plus petite que le pointeur qui la désigne — un comble. Box<String> est une double indirection : le pointeur de la Box mène à un String, qui contient lui-même un pointeur vers son tampon. Et Vec<Box<i32>> disperse en N allocations ce qu'un Vec<i32> range en un seul bloc contigu, ruinant la localité de cache. Aucun de ces Box ne répond à un type récursif ou effacé : ils ne font que coûter.Box<u16> stores on the heap a value smaller than the pointer that designates it — absurd. Box<String> is a double indirection: the Box's pointer leads to a String, which itself holds a pointer to its buffer. And Vec<Box<i32>> scatters across N allocations what a Vec<i32> stores in one contiguous block, wrecking cache locality. None of these Boxes answers a recursive or erased type: they only cost.

// On laisse sur la pile / dans le conteneur ce qui n'a pas besoin du tas
struct Config {
    port: u16,               // ✓ directement, 2 octets
    nom: String,             // ✓ String gère son propre tas, inutile de l'emballer
}

let nombres: Vec<i32> = vec![1, 2, 3];   // ✓ contigu, une seule allocation, cache-friendly

// Box se réserve aux cas qui l'exigent vraiment :
struct Arbre { valeur: i32, gauche: Option<Box<Arbre>>, droite: Option<Box<Arbre>> }
let handlers: Vec<Box<dyn Fn()>> = vec![];   // types effacés, tailles différentes

Les champs simples restent nus ; String et Vec gèrent leur tas tout seuls. Box ne réapparaît que là où il est structurellement nécessaire : l'Arbre récursif (sans Box, taille infinie), la collection de closures de types différents (dyn Fn, tailles hétérogènes). Là, le Box n'est pas un coût gratuit mais la condition d'existence du type. La règle est celle de toute la série : l'outil se mérite par un besoin réel, pas par habitude.Simple fields stay bare; String and Vec manage their heap on their own. Box reappears only where it's structurally necessary: the recursive Arbre (without Box, infinite size), the collection of differently-typed closures (dyn Fn, heterogeneous sizes). There, the Box isn't a free cost but the type's condition of existence. The rule is the whole series': the tool is earned by a real need, not by habit.