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

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

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

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

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

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

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

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

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

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

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

struct Profile {
    name: String,
    score: u32,
}

fn main() {
    let profile = Profile {
        name: String::from("Ada"),
        score: 100,
    };

    let name = profile.name;
    println!("{}", profile.score);
    println!("{}", name);
    // println!("{}", profile.name); // ошибка: поле перемещено
    // drop(profile);                // ошибка: структура частично перемещена
}

Поле name перемещено в переменную name, поэтому обращение к profile.name невозможно. Поле score не затронуто и остаётся доступным. При завершении области видимости Rust освобождает оставшиеся поля структуры отдельно, а перемещённое поле уже освобождается новым владельцем.

Частичное перемещение обычно возникает при деструктуризации или извлечении поля из значения-владельца. Если структура реализует Drop, такой перенос отдельного поля запрещён: Rust не может позволить деструктору работать с частично разрушенным объектом. Для управляемого извлечения в таких случаях применяют, например, замену поля другим корректным значением через std::mem::take или std::mem::replace, если тип поля это допускает.

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

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

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

Возможны три варианта. Клонирование текста проще всего, но создаёт лишнее копирование; передача ссылки не подходит, если следующий компонент должен хранить текст дольше текущего вызова; полное перемещение структуры передаст также идентификатор и лишит обработчик доступа к нему.

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

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

Можно ли после частичного перемещения передать оставшееся поле в отдельную функцию?

Да, если это поле не было перемещено и его тип допускает соответствующее перемещение. Например, после перемещения name поле score можно передать функции как отдельное значение. Нельзя передать саму структуру целиком, поскольку такая операция включает и уже перемещённое поле.

Почему реализация Drop запрещает частичное перемещение?

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

Можно ли восстановить полностью доступную структуру после перемещения поля?

Да, но только если в перемещённое поле записать новое значение подходящего типа. Для этого используют std::mem::replace, передавая замену явно, или std::mem::take, если у типа есть Default. После замены исходная структура снова содержит все поля, однако прежнее значение уже принадлежит новому владельцу и автоматически не возвращается.