Трейт-объекты: как работает динамический полиморфизм в Rust

Введение

#

В прошлых статьях: Статья про RAII, Box, Deref, Введение в трейты мы разобрали базовые трейты и работу с кучей через указатели Box<T>. По умолчанию Rust стремится сделать код максимально быстрым: при использовании обобщенных типов (дженериков) компилятор выполняет мономорфизацию. Он берет функцию и создает ее копию под каждый конкретный тип, получая прямые вызовы.

Однако в реальной разработке бывают задачи, когда типы данных не известны заранее на этапе сборки.

Допустим, мы проектируем систему обработки уведомлений или фоновых задач. У нас есть разные структуры: NetworkTask (сетевой запрос), DbTask (запись в базу) и TimerTask (срабатывание таймера). Все они реализуют общий трейт Task с методом execute(). Мы хотим сложить эти задачи в один список (вектор) и обработать их в цикле.

Но как поместить разные типы в один Vec? Ведь вектор в Rust требует, чтобы все его элементы имели строго одинаковый тип и размер в памяти.

Здесь нам на помощь приходят трейт-объекты и ключевое слово dyn. В этой статье мы разберем, как устроен динамический вызов методов в Rust, откуда берутся «толстые» указатели и как компилятор держит всё под контролем.

1. Статический и динамический подход

#

Чтобы выбрать правильный инструмент, сравним эти два подхода:

Пример разнородной коллекции

#

Чтобы сложить разные типы в один вектор, мы оборачиваем их в указатель Box и указываем ключевое слово dyn:

trait Task { 
    fn execute(&self); 
}

struct NetworkTask;
struct DbTask;

// Реализуем Task для этих структур...

// Складываем разные типы в один вектор
let tasks: Vec<Box<dyn Task>> = vec![
    Box::new(NetworkTask),
    Box::new(DbTask),
];

for task in tasks {
    task.execute(); // Какая именно функция вызовется - вычисляется во время работы
}

2. Размеры типов и ?Sized

#

В Rust почти все типы имеют фиксированный размер в байтах, известный компилятору заранее. Их называют Sized. К примеру, i64 всегда занимает 8 байт, структура из двух i32 - 8 байт. Компилятор точно знает, сколько места выделить под них на стеке.

Но есть типы, размер которых вычисляется только во время работы программы. Их называют DST (Dynamically Sized Types):

• Слайсы текста str
• Слайсы массивов [T]
• Трейт-объекты вида dyn Task

По умолчанию компилятор считает, что любой параметр дженерика должен иметь фиксированный размер (T: Sized). Если мы хотим написать функцию, которая работает с динамическими типами по ссылке, нужно явно отменить это ограничение с помощью синтаксиса ?Sized (“размер может быть неизвестен”):

// T может быть как фиксированного размера, так и динамическим (например, &str или &dyn Debug)
fn print_val<T: ?Sized + std::fmt::Debug>(val: &T) {
    println!("{:?}", val);
}

3. Как устроены «толстые» указатели и таблица методов (vtable)

#

Обычная ссылка в 64-битной системе (например, &i32 или Box<u64>) занимает в памяти 8 байт (одно машинное слово). Это просто адрес в памяти.

Но ссылка на динамический тип &dyn Task или Box<dyn Task> занимает 16 байт (два машинных слова). За такой двойной размер их называют толстыми указателями (Fat Pointers).

Из чего состоят эти 16 байт?

1. Первые 8 байт: адрес самих данных (где лежит структура в куче или на стеке).
2. Вторые 8 байт: адрес таблицы методов (vtable) для конкретного типа.

graph TD
    subgraph FatPointer["Толстый указатель (16 байт)"]
        direction LR
        DataPtr["1. Адрес данных (8 байт)"]
        VtablePtr["2. Адрес vtable (8 байт)"]
    end

    DataMemory["Данные в памяти
──────────────────────
NetworkTask
(структура объекта)"]
    VtableMemory["Таблица методов (vtable)
──────────────────────
vtable для NetworkTask
• Инструкция очистки (Drop)
• Размер типа в байтах (size)
• Выравнивание в памяти (align)
• Указатель на метод execute()"]

    DataPtr --> DataMemory
    VtablePtr --> VtableMemory

    style FatPointer fill:#f4f4f6,stroke:#666,stroke-width:2px,color:#000
    style DataPtr fill:#fff,stroke:#333,color:#000
    style VtablePtr fill:#fff,stroke:#333,color:#000
    style DataMemory fill:#e8f4f8,stroke:#0288d1,stroke-width:2px,color:#000
    style VtableMemory fill:#efebe9,stroke:#5d4037,stroke-width:2px,color:#000

Таблица методов (vtable) на практике

#

Для каждого типа, реализующего трейт, компилятор при сборке создает небольшую статическую таблицу vtable. В ней хранятся:

• Адрес функции очистки ресурсов (Drop).
• Размер объекта и требования к выравниванию в памяти (нужно, чтобы Box знал, сколько байт вернуть ОС при удалении).
• Адреса всех методов, объявленных в трейте.

Когда мы вызываем метод у трейт-объекта:

let task: Box<dyn Task> = Box::new(NetworkTask);
task.execute();

Происходит следующее:

1. Программа считывает второй адрес из толстого указателя и переходит к таблице vtable.
2. Из нужной строчки таблицы берется адрес функции NetworkTask::execute.
3. Функция вызывается, а в качестве первого аргумента &self передается адрес данных из первой половины толстого указателя.

4. Объединение трейтов и почему нельзя написать dyn (Fly + Swim)

#

В Rust нельзя напрямую создать трейт-объект из двух разных трейтов:

// Ошибка компиляции!
fn handle(obj: &(dyn Fly + Swim)) {}

Причина проста: для этого компилятору потребовался бы «трехмерный» указатель (адрес данных + vtable1 + vtable2), что создавало бы путаницу и лишние расходы памяти.

Как решить эту задачу в коде?

#

Мы создаем один обобщённый трейт, который наследует нужные трейты. Затем пишем для него реализацию (Blanket Implementation):

trait Fly { 
    fn fly(&self) -> String; 
}
trait Swim { 
    fn swim(&self) -> String; 
}

// Объединяем требования в один трейт
trait Duck: Fly + Swim {}

// Автоматически реализуем Duck для любого типа, у которого есть и Fly, и Swim
impl<T: Fly + Swim> Duck for T {}

// Теперь dyn Duck абсолютно легален и занимает стандартные 16 байт!
fn handle_duck(duck: &dyn Duck) {
    println!("Утка: {}, {}", duck.fly(), duck.swim());
}

5. Динамическая совместимость (Object Safety)

#

Не любой трейт можно превратить в трейт-объект dyn Trait. Чтобы трейт поддерживал динамический полиморфизм, он должен удовлетворять правилам динамической совместимости (Object Safety).

Суть этих правил легко понять, если вспомнить, как работает vtable: в таблицу можно записать только те методы, которые имеют конкретный фиксированный адрес и принимают ссылку на данные.

Почему некоторые методы ломают Object Safety?

#

1. Метод принимает self по значению (fn run(self)): Передача по значению требует положить объект на стек, но размер dyn Trait не известен во время сборки.
2. Метод использует дженерики (fn process<T>(&self, val: T)): Компилятор генерирует отдельную функцию под каждый T. Поместить бесконечное число вариантов функции в фиксированную таблицу vtable невозможно.
3. Метод не принимает self (fn new() -> Self): Если у метода нет аргумента self, программу нельзя направить в vtable конкретного экземпляра - у нас просто нет объекта, из которого можно прочитать адрес vtable.
4. Метод возвращает или принимает тип Self: В рантайме за dyn Trait могут скрываться совершенно разные структуры, и Rust не сможет гарантировать безопасность типов при их сравнении или передаче.

Практическое решение с помощью where Self: Sized

#

Если вам нужны конструкторы или дженерик-методы при обычной работе с типом, но вы все равно хотите использовать трейт через dyn Trait, добавьте к «проблемным» методам ограничение where Self: Sized:

trait SafeTrait {
    fn name(&self) -> String;
    
    // Этот метод использует Self по значению и сломал бы Object Safety.
    // Ограничение where Self: Sized исключает его из vtable!
    fn copy_by_val(self) -> Self where Self: Sized {
        self
    }
}

Благодаря where Self: Sized компилятор понимает: этот метод будет доступен только при статической типизации, а из таблицы vtable для dyn SafeTrait его можно просто исключить. Трейт остается динамически совместимым!

Давайте посмотрим, как все эти механизмы работают на практике в интерактивных слайдах:

 1trait Task {
 2    fn execute(&self) -> String;
 3}
 4
 5struct NetworkTask;
 6impl Task for NetworkTask {
 7    fn execute(&self) -> String { "Сеть".to_string() }
 8}
 9
10struct DbTask;
11impl Task for DbTask {
12    fn execute(&self) -> String { "База данных".to_string() }
13}
14
15fn main() {
16    // Вектор содержит разные типы данных под общим трейт-объектом
17    let tasks: Vec<Box<dyn Task>> = vec![
18        Box::new(NetworkTask),
19        Box::new(DbTask),
20    ];
21    for t in tasks {
22        println!("Выполняю задачу: {}", t.execute());
23    }
24}
25

 1// По умолчанию все дженерики имеют ограничение T: Sized.
 2// Мы отключаем его с помощью ?Sized, чтобы функция могла принимать слайсы или dyn Trait.
 3fn print_debug<T: ?Sized + std::fmt::Debug>(val: &T) {
 4    println!("Значение: {:?}", val);
 5}
 6
 7fn main() {
 8    let s: &str = "Привет, мир!"; // str - это DST (Dynamically Sized Type)
 9    print_debug(s);
10}
11

 1trait Fly {
 2    fn fly(&self) -> String;
 3}
 4
 5trait Swim {
 6    fn swim(&self) -> String;
 7}
 8
 9// Rust запрещает &(dyn Fly + Swim) напрямую.
10// Создаем общий трейт:
11trait Duck: Fly + Swim {}
12
13// И пишем Blanket-реализацию для всех подходящих типов:
14impl<T: Fly + Swim> Duck for T {}
15
16struct Mallard;
17impl Fly for Mallard {
18    fn fly(&self) -> String { "Летит".to_string() }
19}
20impl Swim for Mallard {
21    fn swim(&self) -> String { "Плывет".to_string() }
22}
23
24fn handle_duck(duck: &dyn Duck) {
25    println!("Утка: {}, {}", duck.fly(), duck.swim());
26}
27
28fn main() {
29    let d = Mallard;
30    handle_duck(&d);
31}
32

 1// Трейт содержит метод `copy_by_val`, который возвращает Self по значению.
 2// Это ломает Object Safety (динамическую совместимость).
 3// Но мы изолируем его с помощью where Self: Sized!
 4trait SafeTrait {
 5    fn name(&self) -> String;
 6    
 7    // Этот метод не будет включен в vtable и не сломает dyn SafeTrait
 8    fn copy_by_val(self) -> Self where Self: Sized {
 9        self
10    }
11}
12
13struct Item;
14impl SafeTrait for Item {
15    fn name(&self) -> String { "Предмет".to_string() }
16}
17
18fn print_name(obj: &dyn SafeTrait) {
19    println!("Имя: {}", obj.name());
20    // obj.copy_by_val(); // Ошибка! Метод недоступен для трейт-объекта.
21}
22
23fn main() {
24    let item = Item;
25    print_name(&item);
26}
27

Проверь свои знания!

#

Пройдите короткий тест, чтобы проверить, насколько хорошо вы разобрались в устройстве трейт-объектов и динамического полиморфизма в Rust.