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

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

fn consume(text: String) {
    drop(text);
}

fn main() {
    let message = String::from("ready");
    consume(message);
}

После передачи message функция consume становится владельцем строки и освобождает её через drop. Локальная переменная message больше не содержит доступного значения и не выполняет второй drop.

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

Rust использует владение и детерминированное освобождение ресурсов как альтернативу одновременному ручному управлению памятью и сборке мусора. Такой подход должен предотвращать двойное освобождение, использование уже освобождённой памяти и утечки из-за неясного владельца.

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

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

Типы вроде String, Vec<T> или Box<T> владеют ресурсами, размещёнными отдельно от самого значения. Если бы после передачи такого объекта оба имени считались владельцами, выход из обеих областей видимости привёл бы к двойному освобождению одного ресурса.

Обратная ошибка также опасна: если Rust перестанет освобождать значение после перемещения, программа получит утечку. Поэтому компилятор должен отслеживать не только тип переменной, но и состояние её инициализации после каждой операции перемещения.

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

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

Компилятор анализирует пути перемещения и состояние инициализации. Если значение полностью перемещено, его прежнее имя не участвует в последующем автоматическом освобождении. Если перемещена только часть составного значения, Rust отслеживает оставшиеся инициализированные части и освобождает именно их.

Для типов с Drop компилятор генерирует так называемое drop glue — необходимую последовательность освобождения самого значения и его полей. Она учитывает, какие части действительно остаются инициализированными. Реализация может использовать внутренние drop-флаги или эквивалентный анализ в зависимости от конкретной структуры программы; полагаться на конкретное представление таких флагов нельзя.

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

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

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

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

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

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

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

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

Всегда ли перемещение физически копирует байты значения?

Нет. Перемещение задаёт семантику владения: новый владелец получает право использовать и уничтожить значение, а старый теряет это право. Для String обычно достаточно передать небольшой дескриптор с указателем, длиной и ёмкостью; данные в куче при этом не дублируются. Однако конкретную машинную реализацию определяет компилятор после оптимизаций.

Почему перемещение String безопасно, хотя строка владеет памятью в куче?

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

Как Rust обрабатывает перемещение, которое происходит только в одной ветви условия?

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