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
Selfni recibirSelfpor 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
- Construye un pequeño sistema de plugins:
trait Command { fn name(&self) -> &str; fn run(&mut self, args: &[&str]) -> String; }y un registroHashMap<String, Box<dyn Command>>. - Reescribe el ejemplo de las figuras con un enum. Mide el rendimiento de
areasumada sobre un millón de figuras con los dos diseños. - 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.¿Cuánto ocupa un
&dyn Traiten una plataforma de 64 bits?2.¿Qué método impide usar un trait como
dyn Traitsalvo que lleve la restricciónwhere Self: Sized?3.¿Cuándo es
dyn Traitmejor elección que los genéricos?