Краткий ответ

Для типа, реализующего Copy, присваивание создаёт побитовую копию значения, поэтому исходная переменная остаётся доступной. При обычном перемещении владение передаётся новой переменной, а исходное имя больше нельзя использовать.

Copy безопасен только для типов, копирование которых не создаёт конкурирующих владельцев одного ресурса. Поэтому тип с String, Vec, Box или другим уникально владеющим полем обычно не может реализовать Copy.

Исторический контекст

Модель владения Rust по умолчанию трактует передачу значения как перемещение, чтобы единственный владелец ресурса был однозначно известен. Это предотвращает двойное освобождение, использование уже освобождённого объекта и другие ошибки управления памятью.

Для простых значений перемещение было бы излишне строгим: целое число или логическое значение не владеют внешним ресурсом. Поэтому Rust предоставляет отдельный маркерный признак Copy, который разрешает неявное копирование таких значений.

Постановка проблемы

Рассмотрим функцию, принимающую аргумент по значению. Для некопируемого типа передача означает перемещение: после вызова исходное значение недоступно. Для Copy-типа передаётся копия, и исходная переменная продолжает существовать.

Если разрешить Copy для типа, содержащего уникальный ресурс, две переменные могли бы выглядеть как владельцы одного ресурса. Их последующее автоматическое освобождение привело бы к двойному освобождению или повреждению памяти. Поэтому компилятор проверяет состав типа и не позволяет объявить такой тип Copy.

Подробное решение

При операции над значением Copy компилятор концептуально вставляет копирование вместо перемещения. Обе переменные получают значения, независимые с точки зрения владения, а исходная переменная не переводится в состояние «перемещено».

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

fn consume(point: Point) {
    println!("{}", point.x);
}

fn main() {
    let first = Point { x: 1, y: 2 };
    let second = first;
    consume(first);
    println!("{}", second.y);
}

После присваивания second = first обе переменные допустимы: Point реализует Copy, потому что все его поля реализуют Copy. Вызов consume(first) также передаёт копию, а не уничтожает доступность first.

Copy не означает глубокое копирование произвольных данных. Например, копирование ссылки &T копирует саму ссылку, то есть адрес и связанные с ним метаданные, но не объект T. Неизменяемая ссылка при этом может быть Copy, а изменяемая ссылка &mut T — нет, поскольку копирование создало бы несколько путей для уникального изменяемого доступа.

Тип может реализовать Copy, только если все его компоненты также Copy и сам тип не реализует Drop. Это ограничение не даёт неявному копированию обходить логику освобождения ресурсов. Для типов, владеющих ресурсами, вместо Copy применяют явный Clone, когда нужно осознанно создать независимую копию.

Важное практическое следствие: Copy влияет на семантику передачи и присваивания, но не гарантирует отсутствие затрат. Для небольших скалярных значений стоимость обычно мала, однако чрезмерное копирование крупных копируемых структур всё равно может ухудшать производительность. Если функция не должна получать владение, более выразительным выбором часто будет заимствование.

Ситуация из практики

Допустим, функция вычисляет метрику и принимает идентификатор записи по значению. Идентификатор представлен небольшой структурой из нескольких целых чисел, поэтому он реализует Copy. После передачи в функцию вызывающему коду всё ещё нужен тот же идентификатор для журналирования и формирования ключа кэша.

Вариант с обычным некопируемым типом потребовал бы либо явного клонирования, либо передачи ссылки. Явный Clone хорошо подходит для крупных значений, когда копирование должно быть заметным, но для небольшого идентификатора добавляет ненужный шум. Ссылка устраняет копирование, однако усложняет сигнатуру временем жизни и может быть неудобна при краткоживущем значении.

Выбранный вариант — небольшой тип-значение с Copy, поскольку его копирование дешёво, не дублирует внешний ресурс и соответствует смыслу идентификатора. В результате функция получает собственное значение, вызывающий код сохраняет доступ к исходному, а владение памятью остаётся однозначным.

Что кандидаты часто упускают

Вопрос: Является ли Copy гарантией глубокого копирования всех данных, связанных со значением?

Нет. Copy означает копирование самого представления значения, а не рекурсивное дублирование объектов, на которые оно может ссылаться. Для &T копируется ссылка, но обе копии указывают на один объект; безопасность сохраняется благодаря правилам заимствования.

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

Вопрос: Почему &mut T не может быть Copy, хотя сама ссылка обычно имеет небольшой размер?

Размер не является главным критерием. &mut T представляет эксклюзивное изменяемое заимствование, и его копирование создало бы две изменяемые ссылки на один объект.

Это нарушило бы гарантию отсутствия одновременных конфликтующих доступов. &mut T можно переместить или временно повторно заимствовать, но нельзя неявно скопировать так, чтобы исходная и новая ссылки одновременно оставались доступными.

Вопрос: Чем Copy отличается от явного вызова Clone с точки зрения контракта API?

Copy разрешает компилятору вставлять копирование неявно при присваивании, передаче аргумента и возврате значения. Пользователь кода может не заметить, что значение было продублировано.

Clone вызывается явно и потому лучше обозначает потенциально затратную операцию или создание независимого владения. Тип может быть Clone, но не Copy; обратное практически связано с тем, что Copy требует доступного Clone и более строгих ограничений на состав типа.