FerrousPath

Nivel 3 · Sistemas· Lección 3 de 11 · 25 min

Trait objects y despacho dinámico

dyn Trait, vtables y punteros gordos, la compatibilidad con dyn, y cómo elegir entre despacho estático y dinámico.

El límite de los genéricos

Un Vec<T> contiene un solo tipo. Una función genérica sobre T: Shape se compila para un T cada vez. Cuando el tipo concreto solo se conoce en tiempo de ejecución —plugins, widgets de una interfaz gráfica, una lista de figuras mezcladas— necesitas despacho dinámico.

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> String {
        "shape".to_string()
    }
}

struct Circle(f64);
struct Rect(f64, f64);

impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.0 * self.0 }
    fn name(&self) -> String { "circle".into() }
}

impl Shape for Rect {
    fn area(&self) -> f64 { self.0 * self.1 }
}

fn largest(shapes: &[Box<dyn Shape>]) -> &dyn Shape {
    shapes
        .iter()
        .max_by(|a, b| a.area().total_cmp(&b.area()))
        .expect("non-empty")
        .as_ref()
}

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![Box::new(Circle(1.0)), Box::new(Rect(2.0, 3.0))];
    for s in &shapes {
        println!("{}: {:.2}", s.name(), s.area());
    }
    println!("largest: {}", largest(&shapes).name());
}

dyn Shape es un trait object (objeto trait): «algún tipo que implementa Shape, por determinar en tiempo de ejecución». Su tamaño no se conoce al compilar, así que siempre vive detrás de un puntero: &dyn Shape, Box<dyn Shape>, Arc<dyn Shape>.

Cómo funciona: punteros gordos y vtables

Un puntero a un trait object ocupa dos palabras:

Box<dyn Shape>
┌────────────┐      ┌──────────────┐
│ data ptr   │ ───▶ │ Circle(1.0)  │
├────────────┤      └──────────────┘
│ vtable ptr │ ───▶ ┌──────────────────────┐
└────────────┘      │ drop_in_place        │
                    │ size, align          │
                    │ <Circle as Shape>::area │
                    │ <Circle as Shape>::name │
                    └──────────────────────┘

Llamar a s.area() carga el puntero a función desde la vtable y hace una llamada indirecta. Existe una vtable por cada pareja (tipo concreto, trait). El coste es una carga de puntero y, sobre todo, la pérdida de la expansión en línea.

use std::mem::size_of;

trait T { fn f(&self); }

fn main() {
    println!("&u8          : {}", size_of::<&u8>());
    println!("&[u8]        : {}", size_of::<&[u8]>());      // puntero + longitud
    println!("&dyn T       : {}", size_of::<&dyn T>());     // puntero + vtable
    println!("Box<dyn T>   : {}", size_of::<Box<dyn T>>());
}

Compatibilidad con dyn

No todos los traits se pueden convertir en un objeto. Un trait es compatible con dyn (dyn-compatible; antes se decía «object safe») solo si todos sus métodos pueden llamarse a través de una vtable sin conocer el tipo concreto. Las reglas principales:

  • Los métodos no pueden ser genéricos sobre tipos (una vtable no puede contener infinitas instancias).
  • Los métodos no pueden devolver Self ni recibir Self por valor en sus argumentos.
  • El trait no puede exigir Self: Sized.
  • Nada de constantes asociadas; las funciones asociadas sin receptor necesitan excluirse explícitamente.

Un método se excluye con where Self: Sized; entonces existe en los tipos concretos pero no en dyn Trait:

trait Animal {
    fn name(&self) -> String;

    fn duplicate(&self) -> Self
    where
        Self: Sized; // excluido de la vtable
}

#[derive(Clone)]
struct Cat;

impl Animal for Cat {
    fn name(&self) -> String { "cat".into() }
    fn duplicate(&self) -> Self { self.clone() }
}

fn main() {
    let a: Box<dyn Animal> = Box::new(Cat);
    println!("{}", a.name());
    // a.duplicate(); // ❌ no está disponible en dyn Animal
    let _c = Cat.duplicate();
}

Por eso Clone no es compatible con dyn, y por eso Iterator sí lo es: todos sus adaptadores genéricos llevan where Self: Sized.

Upcasting y Any

Desde Rust 1.86, un trait object se puede convertir en un objeto de su supertrait:

use std::any::Any;
use std::fmt::Debug;

trait Component: Debug + Any {
    fn update(&mut self);
}

#[derive(Debug)]
struct Health(u32);

impl Component for Health {
    fn update(&mut self) { self.0 = self.0.saturating_sub(1); }
}

fn main() {
    let mut c: Box<dyn Component> = Box::new(Health(10));
    c.update();

    let as_debug: &dyn Debug = &*c;            // upcast a un supertrait
    println!("{as_debug:?}");

    let as_any: &dyn Any = &*c;                // upcast a Any…
    if let Some(h) = as_any.downcast_ref::<Health>() { // …y después downcast al tipo concreto
        println!("health = {}", h.0);
    }
}

El downcasting es una salida de emergencia. Si te descubres haciéndolo de forma habitual, probablemente un enum modele mejor el problema.

¿Estático o dinámico?

Genéricos (impl Trait, T: Trait) Trait objects (dyn Trait)
Despacho directo, se puede expandir en línea indirecto, a través de la vtable
Tamaño del código una copia por tipo una sola copia
Tiempo de compilación crece con las instancias menor
Tipos mezclados en una colección no sí
Necesita compatibilidad con dyn no sí

Y no olvides la tercera opción: un enum. Cuando el conjunto de variantes es cerrado y lo conoces, enum Shape { Circle(..), Rect(..) } con un match es más rápido que dyn, no necesita reservar memoria y obtiene la comprobación de exhaustividad. Usa dyn cuando el conjunto sea abierto: cuando otros crates deban poder añadir implementaciones.

Los punteros a función y las clausuras siguen la misma división: impl Fn(i32) -> i32 es estático; Box<dyn Fn(i32) -> i32> es dinámico y te permite guardar clausuras distintas en un mismo Vec.

Ejercicios

  1. Construye un pequeño sistema de plugins: trait Command { fn name(&self) -> &str; fn run(&mut self, args: &[&str]) -> String; } y un registro HashMap<String, Box<dyn Command>>.
  2. Reescribe el ejemplo de las figuras con un enum. Mide el rendimiento de area sumada sobre un millón de figuras con los dos diseños.
  3. Haz que este trait sea compatible con dyn sin quitar métodos: trait Visitor { fn visit<T: Debug>(&mut self, t: &T); fn done(self) -> String; }.
Pista para el 3

Sustituye el parámetro genérico por &dyn Debug, y o bien añade where Self: Sized a done, o bien cambia su receptor a self: Box<Self>, que sí se puede llamar sobre un Box<dyn Visitor>.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Cuánto ocupa un &dyn Trait en una plataforma de 64 bits?

  2. 2.¿Qué método impide usar un trait como dyn Trait salvo que lleve la restricción where Self: Sized?

  3. 3.¿Cuándo es dyn Trait mejor elección que los genéricos?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?