Вектор объектов, реализующих общий трейт в Rust: как создать и использовать?

Использование трейт-объектов: Box<dyn Trait>

Проблема в вашем коде в том, что трейты в Rust — это не типы с известным размером. Разные структуры (Circle и Rectangle) занимают разное количество памяти. Компилятор не может просто так поместить их в вектор, потому что все элементы вектора должны быть одного размера.

Решение — использовать трейт-объекты через dyn Shape. Это особый тип, который "стирает" конкретный тип, но сохраняет информацию о том, что объект реализует трейт Shape. Поскольку размер dyn Shape тоже неизвестен, мы помещаем его за указатель — Box<dyn Shape>. Box — это умный указатель на кучу, его размер всегда фиксирован (8 байт на 64-битной системе).

Исправленный код:

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

fn main() {
    // Создаём вектор трейт-объектов
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 2.0 }),
        Box::new(Rectangle { width: 3.0, height: 4.0 }),
    ];
    
    // Вызов метода через трейт-объект
    for shape in &shapes {
        println!("Area: {}", shape.area());
    }
    // Вывод:
    // Area: 12.566370614359172
    // Area: 12
}

Что такое dyn и как это работает под капотом?

Ключевое слово dyn явно указывает, что мы используем динамическую диспетчеризацию. Вместо того чтобы вызывать конкретный метод (как для Circle::area или Rectangle::area), компилятор генерирует таблицу виртуальных функций (vtable). Каждый Box<dyn Shape> хранит два указателя:

• Указатель на данные (например, на структуру Circle в куче).
• Указатель на vtable — таблицу с адресами методов трейта для данного конкретного типа.

Это добавляет небольшие накладные расходы (один дополнительный разыменование указателя) по сравнению со статической диспетчеризацией (через дженерики), но даёт гибкость: вы можете хранить разные типы в одной коллекции.

Альтернатива: дженерики (статическая диспетчеризация)

Если вам не нужен именно вектор с разными типами, а достаточно функции, которая работает с любым типом, реализующим Shape, используйте дженерики:

fn print_area<T: Shape>(shape: &T) {
    println!("Area: {}", shape.area());
}

fn main() {
    let circle = Circle { radius: 2.0 };
    let rect = Rectangle { width: 3.0, height: 4.0 };
    print_area(&circle); // Статическая диспетчеризация
    print_area(&rect);   // Компилятор создаст отдельную копию функции для каждого типа
}

Важные ограничения трейт-объектов

Не каждый трейт можно превратить в трейт-объект. Трейт должен быть object-safe:

• Методы не могут возвращать Self (конкретный тип).
• Методы не могут иметь обобщённые параметры (дженерики).
• Трейт не может быть автоматически реализован для всех типов (как Clone или Copy).

Если ваш трейт нарушает эти правила, компилятор выдаст ошибку the trait cannot be made into an object.

enum ShapeEnum {
    Circle(Circle),
    Rectangle(Rectangle),
}

impl ShapeEnum {
    fn area(&self) -> f64 {
        match self {
            ShapeEnum::Circle(c) => c.area(),
            ShapeEnum::Rectangle(r) => r.area(),
        }
    }
}

fn main() {
    let shapes: Vec<ShapeEnum> = vec![
        ShapeEnum::Circle(Circle { radius: 2.0 }),
        ShapeEnum::Rectangle(Rectangle { width: 3.0, height: 4.0 }),
    ];
    
    for shape in &shapes {
        println!("Area: {}", shape.area());
    }
}