Как реализовать трейт Copy в Rust для пользовательского типа?

Почему возникает ошибка и как её исправить

Вы почти на верном пути, но в Rust есть важное правило: трейт Copy является супертрейтом (super-trait) для Clone. Это значит, что любой тип, реализующий Copy, обязан также реализовать Clone. Компилятор сообщает вам именно это: без Clone вы не можете реализовать Copy.

Правильное решение

Самый простой способ — добавить аннотацию #[derive(Copy, Clone)] над вашей структурой. Это заставит компилятор автоматически сгенерировать реализации обоих трейтов:

#[derive(Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = p1; // Копирование, а не перемещение

    println!("p1: ({}, {}), p2: ({}, {})", p1.x, p1.y, p2.x, p2.y);
    // p1 всё ещё доступен!
}

Когда это работает?

Автоматическая реализация Copy и Clone через derive возможна только если все поля вашей структуры сами реализуют эти трейты. В вашем случае поля x и y имеют тип i32, который реализует и Copy, и Clone, поэтому всё работает.

Что если поля не реализуют Copy?

Представьте, что вы добавили поле типа String:

struct Person {
    name: String,
    age: i32,
}

Тогда #[derive(Copy, Clone)] не сработает, потому что String не реализует Copy (она управляется через указатель на кучу). В этом случае придётся реализовывать Clone вручную, а Copy — вообще не реализовывать (потому что глубокое копирование строки — это дорогая операция, и компилятор не должен делать её неявно).

Ручная реализация (на случай, если вам нужно больше контроля)

Если вы хотите написать реализацию вручную, это выглядит так:

struct Point {
    x: i32,
    y: i32,
}

impl Clone for Point {
    fn clone(&self) -> Self {
        Point {
            x: self.x,
            y: self.y,
        }
    }
}

impl Copy for Point {} // Теперь это работает, потому что Clone уже реализован

Но для простых структур derive — это идиоматичный и предпочтительный способ.

Важные правила для Copy

• Только для простых типов: Copy предназначен для типов, которые можно скопировать простым побитовым копированием (как числа или указатели).
• Неявное копирование: при присваивании let y = x; компилятор вставляет вызов clone() автоматически, но только если тип реализует Copy.
• Нельзя для типов с нетривиальным владением: String, Vec, Box и другие типы, управляющие памятью, не могут быть Copy, чтобы избежать двойного освобождения памяти.

Теперь ваша структура Point будет работать как простой тип — копироваться неявно, и исходная переменная останется доступной.

#[derive(Clone)]
struct Person {
    name: String,
    age: i32,
}

fn main() {
    let p1 = Person { name: "Alice".to_string(), age: 30 };
    let p2 = p1.clone(); // Явное копирование
    // p1 остаётся доступным, потому что clone() не перемещает данные
}