Box de T: el valor que vive en el heap

Box<T> es el más simple de los punteros inteligentes y el cimiento sobre el que se apoyan los demás: un único dueño de una asignación en el heap. No comparte, no cuenta referencias, no sincroniza; toma un valor, lo coloca en el montón y te entrega un puntero del tamaño de una palabra que lo posee. La pregunta que importa no es cómo se usa —es trivial— sino cuándo hace falta: casi nunca por capricho, casi siempre porque el tamaño del valor no puede conocerse en la pila. Tres situaciones lo vuelven imprescindible, y las tres son la misma frase dicha de tres maneras.

Un dueño, un heap

Box::new(v) mueve v al heap y devuelve un Box<T> que lo posee en exclusiva. El Box implementa Deref hacia T —así que *b te da acceso al valor— y DerefMut si lo tienes mutable; al salir de scope, su Drop libera la asignación de forma determinista. Es un dueño como cualquier otro valor poseído: moverlo transfiere la propiedad del dato en el heap, y no existe forma de que dos Box apunten al mismo sitio (eso es territorio de Rc y Arc).

fn main() {
    let en_heap: Box<i32> = Box::new(5);
    println!("{en_heap}");       // Deref a &i32: imprime 5
    let n = *en_heap + 1;        // *en_heap desreferencia al i32 alojado
    println!("{n}");
} // al salir de scope, el Drop de Box libera la memoria

Para un i32 esto es un despilfarro: nadie mete un entero en el heap sin motivo. Box gana sentido justo cuando poner el valor en la pila es imposible, no cuando es meramente caro. Su representación es un solo puntero no nulo hacia el dato: ni cabecera, ni contador, ni metadato adjunto.

El tamaño infinito: tipos recursivos

El caso canónico es un tipo que se contiene a sí mismo. Una lista enlazada ingenua no compila:

// NO compila: "recursive type `Lista` has infinite size"
// enum Lista {
//     Cons(i32, Lista),
//     Nil,
// }

El compilador calcula el tamaño de un enum como el de su variante mayor. Aquí Cons contiene un Lista, que contiene un Cons, que contiene un Lista… la recursión no tiene fondo y el tamaño diverge. La indirección lo corta: Box<Lista> es un puntero de tamaño fijo —una palabra— sea cual sea el tamaño de aquello a lo que apunta.

enum Lista {
    Cons(i32, Box<Lista>),
    Nil,
}
use Lista::{Cons, Nil};

fn main() {
    let lista = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
    if let Cons(cabeza, _) = &lista {
        println!("cabeza = {cabeza}");   // cada Cons mide i32 mas un puntero
    }
}

flowchart LR
s[Pila: variable lista] --> c1[Cons 1 en heap]
c1 -->|Box| c2[Cons 2 en heap]
c2 -->|Box| c3[Cons 3 en heap]
c3 -->|Box| n[Nil]
style s fill:#89b4fa,color:#11111b
style n fill:#a6e3a1,color:#11111b

El mismo argumento vale para un árbol: struct Nodo { valor: i32, izq: Option<Box<Nodo>>, der: Option<Box<Nodo>> }. Cada rama es un puntero de tamaño conocido, y el árbol entero se vuelve representable. Sin Box, ningún tipo autorreferente cabría en la pila.

Trait objects y valores grandes

Las otras dos situaciones son variantes de “el tamaño no se conoce en la pila”. Un trait object dyn Trait es ?Sized: no tiene tamaño conocido en compilación, así que no puede vivir suelto. Box<dyn Trait> le da un manejador de tamaño fijo —un puntero gordo con la vtable, como viste en el nivel 15— y por eso Box<dyn Error> o Vec<Box<dyn Forma>> son idiomáticos.

fn crear() -> Box<dyn std::fmt::Display> {
    Box::new(String::from("un valor cualquiera"))  // el tipo concreto se borra
}

El tercer caso es de rendimiento: mover un valor grande copia sus bytes de una posición de pila a otra, mientras que mover un Box copia solo el puntero. Y un enum con una variante enorme y varias diminutas malgasta memoria en cada valor pequeño; encajar la variante grande en un Box mantiene el enum compacto —la advertencia large_enum_variant de Clippy señala justamente esto—.

Coste cero

Box es el ejemplo de manual de abstracción de coste cero: su representación es un puntero, idéntico al que devolvería un malloc a mano en C; su Deref compila a una carga de memoria; su Drop, a un free. No hay contador de referencias, ni cabecera, ni trabajo en tiempo de ejecución más allá de la asignación que tú pediste explícitamente. Pagas por el heap, y por nada más.