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

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

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

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

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

Box<T> предоставляет владение объектом, размещённым в куче. Отдельное хранение объекта в куче и указателя-владельца позволяет перемещать сам указатель без копирования большого или несостоящего из Copy объекта.

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

Пусть переменная владеет Box<T>, а из него получена ссылка на T. Затем программу пытаются передать Box в другую переменную. На уровне машинной модели адрес объекта может остаться неизменным, но исходная переменная перестаёт быть владельцем.

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

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

Перемещение Box<T> перемещает значение самого Box, то есть владение ссылочным указателем. Выделенный T при этом не копируется и не перемещается вслед за указателем: его адрес сохраняется, пока существует владелец Box.

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

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

fn main() {
    let value = Box::new(String::from("rust"));
    let view = &value[..];

    println!("{view}");
    let moved = value;
    println!("{moved}");
}

Здесь view используется до перемещения value, поэтому компилятор видит, что ссылка больше не нужна. Перемещение value в moved передаёт владение Box; строка в куче при этом не копируется.

Если попытаться переместить value до последнего использования view, компиляция завершится ошибкой. Даже если программист знает, что адрес объекта не изменится, безопасная модель должна учитывать не только физический адрес, но и то, кто отвечает за освобождение памяти.

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

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

Сервис разбирает крупный документ и передаёт его между этапами обработки. Документ хранится в Box<Document>, а один этап временно создаёт ссылки на его части. Если передать Box следующему этапу до завершения работы с этими ссылками, компилятор отвергнет программу.

Возможны три подхода:

клонировать документ или его части — просто для понимания, но затратно по памяти и времени;
заменить ссылки индексами или идентификаторами узлов — ссылки не блокируют передачу владения, но усложняют доступ и требуют проверки актуальности индексов;
завершить использование ссылок до передачи Box — обычно самый дешёвый и ясный вариант, если этапы можно разделить на последовательные фазы.

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

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

1. Может ли перемещение Box<T> изменить адрес самого T?

Нет, обычное перемещение Box<T> перемещает значение указателя, а не объект, на который он указывает. Поэтому адрес выделенного объекта в куче сохраняется, пока объект не будет освобождён или явно перемещён другим способом. Однако это не означает, что любую ссылку на T можно использовать после перемещения Box: правила заимствования проверяют действительность владения, а не только неизменность адреса.

2. Почему ссылка может запрещать перемещение владельца, если новый владелец продолжит жить дольше?

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

Обычно безопасный способ — сначала передать ссылку в нужную функцию или использовать её в последнем выражении, затем выполнить перемещение. Если требуется одновременно владеть объектом и выдавать стабильные handles, применяют отдельную архитектуру хранения, например арены с подходящей моделью времени жизни, а не обходят проверку перемещения.

3. Чем Box<T> отличается от ссылки &T с точки зрения освобождения памяти?

&T только заимствует объект и не отвечает за его освобождение. Box<T> владеет объектом: при уничтожении последнего Box вызываются необходимые операции освобождения T и памяти.

Поэтому Box<T> можно передать другой функции или структуре как собственность, а ссылка обязана оставаться в пределах доказуемого времени жизни владельца. Цена владения через Box — выделение объекта в куче и косвенный доступ; преимущество — единственный ясный владелец и возможность безопасно передавать крупный объект без копирования.