Что такое trait object в Rust и как его создать?

Что такое trait object?

Trait object (объект-трейт) — это способ работать с разными типами, реализующими один и тот же трейт, через единый интерфейс, когда конкретный тип неизвестен во время компиляции. Это своего рода "стирание типа" (type erasure) — вы знаете, что объект умеет делать (какие методы трейта у него есть), но не знаете, какой конкретно это тип.

Как это работает под капотом?

Trait object хранится как fat pointer (жирный указатель), состоящий из двух частей:

• Указатель на данные — адрес самого объекта в куче (если используется Box) или на стеке (если используется ссылка).
• Указатель на vtable — таблица виртуальных методов (virtual method table). Это структура, содержащая указатели на все методы трейта для конкретного типа.

Когда вы вызываете метод через trait object, Rust:

1. Берёт vtable из fat pointer
2. Находит в нём нужный метод по смещению
3. Вызывает его с указателем на данные в качестве self

Это называется динамической диспетчеризацией (dynamic dispatch) — вызов метода разрешается во время выполнения, а не на этапе компиляции.

Зачем нужен dyn?

Ключевое слово dyn было введено в Rust 2018 edition, чтобы явно указать, что используется динамическая диспетчеризация. Раньше писали просто Box<Animal>, но это было неочевидно. dyn Animal означает: "это trait object для трейта Animal".

Примеры использования

Вот как работает ваш пример с trait object'ами:

fn main() {
    // Создаём вектор trait object'ов
    let mut animals: Vec<Box<dyn Animal>> = Vec::new();
    
    animals.push(Box::new(Dog));
    animals.push(Box::new(Cat));
    
    // Динамическая диспетчеризация
    for animal in &animals {
        animal.speak(); // Вызовется правильный метод для каждого типа
    }
}

Альтернативный вариант с ссылками (без кучи):

fn make_speak(animal: &dyn Animal) {
    animal.speak();
}

fn main() {
    let dog = Dog;
    let cat = Cat;
    
    make_speak(&dog as &dyn Animal);
    make_speak(&cat);
}

Ограничения trait object'ов

Не все трейты можно превратить в trait object. Есть ограничения:

• Object Safety — трейт должен быть "объектно-безопасным". Основные правила:
  • Методы не могут возвращать Self (конкретный тип)
  • Методы не могут иметь generic параметры
  • Трейт не должен наследоваться от необъектно-безопасного трейта
• Пример небезопасного трейта:

  trait Clone {
      fn clone(&self) -> Self; // Self нельзя, потому что размер неизвестен
  }
  
  // Это не скомпилируется:
  // let x: Box<dyn Clone> = Box::new(42);
  

• Trait object всегда имеет ?Sized — размер известен только во время выполнения.

Когда использовать trait object?

• Когда нужна гетерогенная коллекция (разные типы в одном векторе)
• Когда типы неизвестны на этапе компиляции (плагины, конфигурации)
• Когда количество вариантов велико или динамически расширяется

Альтернативы

Если количество типов фиксировано и известно, лучше использовать enum — это быстрее (статическая диспетчеризация) и безопаснее:

enum AnimalEnum {
    Dog(Dog),
    Cat(Cat),
}

impl AnimalEnum {
    fn speak(&self) {
        match self {
            AnimalEnum::Dog(d) => d.speak(),
            AnimalEnum::Cat(c) => c.speak(),
        }
    }
}

Или generics с мономорфизацией, если типы известны во время компиляции.

В итоге: trait object — это мощный инструмент для полиморфизма в Rust, но используйте его осознанно, понимая, что вы платите за гибкость производительностью (динамическая диспетчеризация) и ограничениями Object Safety.

use std::fmt::Display;

fn print_dynamic(items: Vec<Box<dyn Display>>) {
    for item in items {
        println!("{}", item);
    }
}

fn main() {
    let items: Vec<Box<dyn Display>> = vec![
        Box::new(42),
        Box::new("hello"),
        Box::new(3.14),
    ];
    print_dynamic(items);
}

fn make_sound<T: Animal>(animal: &T) {
    animal.speak();
}